mirror of
https://github.com/caperren/school_archives.git
synced 2025-11-10 06:01:13 +00:00
339 lines
11 KiB
Java
339 lines
11 KiB
Java
/*
|
|
* Licensed to the Apache Software Foundation (ASF) under one or more
|
|
* contributor license agreements. See the NOTICE file distributed with
|
|
* this work for additional information regarding copyright ownership.
|
|
* The ASF licenses this file to You under the Apache License, Version 2.0
|
|
* (the "License"); you may not use this file except in compliance with
|
|
* the License. You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
import java.io.BufferedReader;
|
|
import java.io.File;
|
|
import java.io.FileNotFoundException;
|
|
import java.io.FileReader;
|
|
import java.io.IOException;
|
|
import java.io.LineNumberReader;
|
|
import java.util.Random;
|
|
|
|
import junit.framework.TestCase;
|
|
|
|
/**
|
|
* Performs Validation Test for url validations.
|
|
*
|
|
* @version $Revision: 1128446 $ $Date: 2011-05-27 13:29:27 -0700 (Fri, 27 May
|
|
* 2011) $
|
|
*/
|
|
public class UrlValidatorTest extends TestCase {
|
|
|
|
private boolean printStatus = false;
|
|
private boolean printIndex = false;// print index that indicates current
|
|
// scheme,host,port,path, query test
|
|
// were using.
|
|
|
|
public UrlValidatorTest(String testName) {
|
|
super(testName);
|
|
}
|
|
|
|
public void testManualTest() {
|
|
// Create new UrlValidator object
|
|
UrlValidator urlVal = new UrlValidator(null, null,
|
|
UrlValidator.ALLOW_ALL_SCHEMES);
|
|
|
|
// Manual Tests:
|
|
|
|
// These should return True
|
|
System.out.println("The following should return true:");
|
|
System.out.println(urlVal.isValid("http://www.amazon.com"));
|
|
System.out.println(urlVal.isValid("http://www.google.com"));
|
|
System.out.println(urlVal.isValid("http://www.com")); // Oddly enough
|
|
// this is a
|
|
// legit website
|
|
System.out.println(urlVal.isValid("http://www.GOOGLE.com"));
|
|
System.out.println(urlVal.isValid("HTTP://WWW.GOOGLE.COM"));
|
|
System.out.println(urlVal.isValid("http://WWW.google.COM"));
|
|
System.out.println(urlVal.isValid("reddit.com")); // RETURNS FALSE
|
|
|
|
// These should return False
|
|
System.out.println("The following should return false:");
|
|
System.out.println(urlVal.isValid("http://www.invalid"));
|
|
System.out.println(urlVal.isValid("reddit"));
|
|
System.out.println(urlVal.isValid("www.reddit"));
|
|
System.out.println(urlVal.isValid("al;skdjfals;kdjgas"));
|
|
System.out.println(urlVal.isValid("www.:).com"));
|
|
|
|
}
|
|
|
|
/*
|
|
* The URLValidator can be split up into two disjoint sets of tests, tests
|
|
* that should pass and tests that should fail. This is consistent with an
|
|
* explanation of Input Domain Partitioning as found in an article written
|
|
* by Tomas Vagoun for the Annual Hawaii International Conference on System
|
|
* Sciences (https://goo.gl/acd0IL).
|
|
*
|
|
* This verifies that the basics of the validator do work, and approaching
|
|
* this problem as black box testing is some of the best that we can do.
|
|
*/
|
|
|
|
public void testYourFirstPartition() {
|
|
UrlValidator urlVal = new UrlValidator(null, null,
|
|
UrlValidator.ALLOW_ALL_SCHEMES);
|
|
|
|
String test;
|
|
|
|
// This extremely ubiquitous URL is obviously completely true, and as
|
|
// such, the validator should return true.
|
|
|
|
test = "http://www.google.com";
|
|
if (urlVal.isValid(test) == true) {
|
|
System.out.println("Passed correctly at " + test + ".");
|
|
} else {
|
|
System.out.println("Failed incorrectly at " + test + ".");
|
|
}
|
|
|
|
// This test happened to fail, so I wrote my bug report about it
|
|
test = "http://www.google.xxx";
|
|
if (urlVal.isValid(test) == true) {
|
|
System.out.println("Passed correctly at " + test + ".");
|
|
} else {
|
|
System.out.println("Failed incorrectly at " + test + ".");
|
|
}
|
|
|
|
// This test happened to fail, so I wrote my bug report about it
|
|
test = "http://www.peta.xxx";
|
|
if (urlVal.isValid(test) == true) {
|
|
System.out.println("Passed correctly at " + test + ".");
|
|
} else {
|
|
System.out.println("Failed incorrectly at " + test + ".");
|
|
}
|
|
|
|
}
|
|
|
|
public void testYourSecondPartition() {
|
|
UrlValidator urlVal = new UrlValidator(null, null,
|
|
UrlValidator.ALLOW_ALL_SCHEMES);
|
|
|
|
String test;
|
|
|
|
// But we can detect that the isvalid fails on a known incorrect version
|
|
// so prove that it can still detect invalid URLs.
|
|
test = "http://www.google.government";
|
|
if (urlVal.isValid(test) == false) {
|
|
System.out.println("Failed correctly at " + test + ".");
|
|
} else {
|
|
System.out.println("Failed incorrectly at " + test + ".");
|
|
}
|
|
|
|
}
|
|
|
|
public void testIsValid() {
|
|
// Print out that we're starting
|
|
System.out.println("Starting programmatically generated tests!");
|
|
|
|
// Make an instance of the url validator class
|
|
UrlValidator url_validator = new UrlValidator(null, null,
|
|
UrlValidator.ALLOW_ALL_SCHEMES);
|
|
|
|
// Instantiate the random number generator
|
|
Random random_generator = new Random();
|
|
|
|
// Read in result pair arrays from the files that contain the test input
|
|
ResultPair[] test_schemes = get_result_pairs_from_file("test_files/test_schemes.txt");
|
|
ResultPair[] test_authorities = get_result_pairs_from_file("test_files/test_authorities.txt");
|
|
ResultPair[] test_ports = get_result_pairs_from_file("test_files/test_ports.txt");
|
|
ResultPair[] test_paths = get_result_pairs_from_file("test_files/test_paths.txt");
|
|
|
|
// Set up some variables for keeping track of suceeded/failed tests.
|
|
int match_count = 0;
|
|
int fail_count = 0;
|
|
|
|
// Main loop that will run the programmatic tests for so many times
|
|
for (int i = 0; i < 100000; i++) {
|
|
// Set up variables for another run through the loop
|
|
String full_url_string = "";
|
|
Boolean expected_validity = true;
|
|
int current_rand = -1;
|
|
|
|
// Get a random scheme, concatenate its string with the full url,
|
|
// and bitwise and its validity result so the result becomes false
|
|
// if necessary
|
|
current_rand = random_generator.nextInt(test_schemes.length);
|
|
full_url_string += test_schemes[current_rand].item;
|
|
expected_validity &= test_schemes[current_rand].valid;
|
|
|
|
// Get a random authority, concatenate its string with the full url,
|
|
// and bitwise and its validity result so the result becomes false
|
|
// if necessary
|
|
current_rand = random_generator.nextInt(test_authorities.length);
|
|
full_url_string += test_authorities[current_rand].item;
|
|
expected_validity &= test_authorities[current_rand].valid;
|
|
|
|
// Get a random port, concatenate its string with the full url,
|
|
// and bitwise and its validity result so the result becomes false
|
|
// if necessary
|
|
current_rand = random_generator.nextInt(test_ports.length);
|
|
full_url_string += test_ports[current_rand].item;
|
|
expected_validity &= test_ports[current_rand].valid;
|
|
|
|
// Get a random path, concatenate its string with the full url,
|
|
// and bitwise and its validity result so the result becomes false
|
|
// if necessary
|
|
current_rand = random_generator.nextInt(test_paths.length);
|
|
full_url_string += test_paths[current_rand].item;
|
|
expected_validity &= test_paths[current_rand].valid;
|
|
|
|
// Get the result of isValid from the url validator
|
|
Boolean actual_validity = url_validator.isValid(full_url_string);
|
|
|
|
// Make a boolean that tells us whether the expected and actual
|
|
// validities match
|
|
Boolean validities_match = (actual_validity == expected_validity);
|
|
|
|
if (validities_match) {
|
|
// If they match, increment our success counter.
|
|
match_count++;
|
|
|
|
} else {
|
|
// Otherwise, print the failed url, and increment our fail count
|
|
// Here, I also have another call to isValid that can be
|
|
// uncommented for easy debugging of the failed url
|
|
System.out.println("Failed on url: " + full_url_string);
|
|
url_validator.isValid(full_url_string);
|
|
fail_count++;
|
|
}
|
|
|
|
}
|
|
|
|
// Print that the test is over
|
|
System.out.println("Programmatically generated tests complete!");
|
|
|
|
// Print the number of successes
|
|
System.out.println(match_count + " tests succeeded!");
|
|
|
|
// If there are failures, print the number of failures and a large
|
|
// warning.
|
|
if (fail_count > 0) {
|
|
System.out.println("SOME TESTS FAILED!!!!");
|
|
System.out.println(fail_count + " tests failed!");
|
|
}
|
|
|
|
}
|
|
|
|
private ResultPair[] get_result_pairs_from_file(String filename) {
|
|
// Create some file reading classes
|
|
FileReader file_reader = null;
|
|
BufferedReader buffered_reader = null;
|
|
|
|
// Get the number of lines that are in the file
|
|
int num_lines = get_num_lines_in_file(filename);
|
|
|
|
// Try and open the file reader on the file or handle exceptions
|
|
try {
|
|
file_reader = new FileReader(filename);
|
|
} catch (FileNotFoundException e) {
|
|
e.printStackTrace();
|
|
}
|
|
|
|
// Put this reader into the buffered reader to make it easy to work with
|
|
buffered_reader = new BufferedReader(file_reader);
|
|
|
|
// Create a result pair array with the correct number of entries
|
|
ResultPair[] pairs = new ResultPair[num_lines];
|
|
|
|
// Variable to hold the current line from the reader
|
|
String current_line = null;
|
|
|
|
// Do and initial read to start off, or handle exceptions
|
|
try {
|
|
current_line = buffered_reader.readLine();
|
|
} catch (IOException e1) {
|
|
e1.printStackTrace();
|
|
}
|
|
|
|
// For the number of lines in the file, loop
|
|
for (int i = 0; i < num_lines; i++) {
|
|
// Encapsulate in try block to hand exceptions
|
|
try {
|
|
// Split the current line by tabs, so there will be two indexes,
|
|
// one with the string, and one saying whether it's valid
|
|
String[] split_by_tab = current_line.split("\\t");
|
|
|
|
// Set the name to the first index
|
|
String name = split_by_tab[0];
|
|
|
|
// Create and empty bool for validity
|
|
Boolean is_valid = null;
|
|
|
|
// Check the validity string in index one, and set the validity
|
|
// boolean accordingly
|
|
if (split_by_tab[1].equals("valid")) {
|
|
is_valid = true;
|
|
} else {
|
|
is_valid = false;
|
|
}
|
|
|
|
// Set the current index of the result pair array to a new
|
|
// result pair with the name and validity
|
|
pairs[i] = new ResultPair(name, is_valid);
|
|
|
|
// Read a new line for the next run through the loop
|
|
current_line = buffered_reader.readLine();
|
|
} catch (IOException e) {
|
|
e.printStackTrace();
|
|
}
|
|
|
|
}
|
|
|
|
// Now we're done, so close the file or handle exceptions
|
|
try {
|
|
buffered_reader.close();
|
|
} catch (IOException e) {
|
|
e.printStackTrace();
|
|
}
|
|
|
|
// Return our new array of pairs
|
|
return pairs;
|
|
}
|
|
|
|
private int get_num_lines_in_file(String filename) {
|
|
// Create a line number reader
|
|
LineNumberReader line_reader = null;
|
|
|
|
// Make a line reader and handle exceptions
|
|
try {
|
|
line_reader = new LineNumberReader(new FileReader(
|
|
new File(filename)));
|
|
} catch (FileNotFoundException e) {
|
|
e.printStackTrace();
|
|
}
|
|
|
|
// Skip to the end of the file or handle exceptions
|
|
try {
|
|
line_reader.skip(Long.MAX_VALUE);
|
|
} catch (IOException e) {
|
|
e.printStackTrace();
|
|
}
|
|
|
|
// Get the number of lines the reader has read. The extra one makes it
|
|
// one indexed.
|
|
int number_of_lines = line_reader.getLineNumber() + 1;
|
|
|
|
// Close the file, or handle exceptions
|
|
try {
|
|
line_reader.close();
|
|
} catch (IOException e) {
|
|
e.printStackTrace();
|
|
}
|
|
|
|
// Return the number of lines we found
|
|
return number_of_lines;
|
|
}
|
|
}
|