public void testValidator204() {
String[] schemes = {"http", "https"};
UrlValidator urlValidator = new UrlValidator(schemes);
assertTrue(
urlValidator.isValid(
"http://tech.yahoo.com/rc/desktops/102;_ylt=Ao8yevQHlZ4On0O3ZJGXLEQFLZA5"));
}
public void testValidator202() {
String[] schemes = {"http", "https"};
UrlValidator urlValidator = new UrlValidator(schemes, UrlValidator.NO_FRAGMENTS);
// UrlValidator urlValidator = new UrlValidator(schemes, UrlValidator.ALLOW_ALL_SCHEMES);
assertTrue(
urlValidator.isValid(
"http://www.logoworks.comwww.logoworks.comwww.logoworks.comwww.logoworks.comwww.logoworks.comwww.logoworks.comwww.logoworks.comwww.logoworks.comwww.logoworks.comwww.logoworks.comwww.logoworks.comwww.logoworks.comwww.logoworks.comwww.logoworks.comwww.logoworks.comwww.logoworks.comwww.logoworks.comwww.logoworks.comwww.logoworks.comwww.logoworks.comwww.logoworks.comwww.logoworks.comwww.logoworks.comwww.logoworks.comwww.logoworks.comwww.logoworks.comwww.logoworks.comwww.logoworks.comwww.logoworks.comwww.org"));
}
// Manual testing
public void testManualTest() {
UrlValidator urlVal = new UrlValidator(null, null, UrlValidator.ALLOW_ALL_SCHEMES);
System.out.println("Running testManualTest():");
System.out.println("=========================");
String testURLsValid[] = {
// add URLs here manually to test
"http://www.amazon.com", // valid
"http://www.google.com/drive", // valid
"http://www.google.com/", // valid
"http://google.com/", // valid
"http://validator.w3.org/feed/check.cgi?url=http://www.google.com/", // valid
"http://www.googl3.com/", // valid
"http://wwww.google.com/ ", // valid
"http://ww.google.com/", // valid
"173.194.121.32", // valid
"http://www.net" // valid
};
String testURLsInvalid[] = {
// add URLs here to manually test
"http://www..net", // invalid
"http://www.google.com//", // invalid
"http://www.goog|e.com/", // invalid
"http://www.googl3.c0m/", // invalid
"http://www.google.com /drive", // invalid
"http://www.google.com/ drive", // invalid
"http://www.google.com/ drive", // invalid
"http://www.google.com /drive", // invalid
"http://www.google.com/ drive ", // invalid
"http://www .google.com/drive", // invalid
"http://www.google .com/drive", // invalid
"http://www."
};
System.out.println(" -Testing Valid Urls:");
for (int i = 0; i < testURLsValid.length; i++) {
if (urlVal.isValid(testURLsValid[i]) == false) {
System.out.println(" *Bug found: '" + testURLsValid[i] + "': isValid() returned false.");
}
// System.out.println("'" + testURLsValid[i] + "' || result=" +
// urlVal.isValid(testURLsValid[i]));
}
System.out.println(" -Testing Invalid Urls:");
for (int i = 0; i < testURLsInvalid.length; i++) {
if (urlVal.isValid(testURLsInvalid[i]) == true) {
System.out.println(
" *Bug found: '" + testURLsInvalid[i] + "': isValid() returned true.");
}
// System.out.println("'" + testURLsValid[i] + "' || result=" +
// urlVal.isValid(testURLsValid[i]));
}
System.out.println("========================");
System.out.println("Manual Testing Completed");
}
public void testValidator248() {
RegexValidator regex = new RegexValidator(new String[] {"localhost", ".*\\.my-testing"});
UrlValidator validator = new UrlValidator(regex, 0);
assertTrue(
"localhost URL should validate", validator.isValid("http://localhost/test/index.html"));
assertTrue(
"first.my-testing should validate",
validator.isValid("http://first.my-testing/test/index.html"));
assertTrue(
"sup3r.my-testing should validate",
validator.isValid("http://sup3r.my-testing/test/index.html"));
assertFalse(
"broke.my-test should not validate",
validator.isValid("http://broke.my-test/test/index.html"));
assertTrue(
"www.apache.org should still validate",
validator.isValid("http://www.apache.org/test/index.html"));
// Now check using options
validator = new UrlValidator(UrlValidator.ALLOW_LOCAL_URLS);
assertTrue(
"localhost URL should validate", validator.isValid("http://localhost/test/index.html"));
assertTrue(
"machinename URL should validate", validator.isValid("http://machinename/test/index.html"));
assertTrue(
"www.apache.org should still validate",
validator.isValid("http://www.apache.org/test/index.html"));
}
// Test ports 0-65535
public void testPorts() {
String url;
String schemes[] = {"http", "https"};
UrlValidator urlVal = new UrlValidator(schemes);
for (int i = 0; i < 65536; i++) {
url = "http://www.google.com:" + Integer.toString(i);
if (!urlVal.isValid(url)) {
System.out.println("TEST Failed: " + url);
}
}
}
public void testYourSecondPartition() {
UrlValidator urlVal = new UrlValidator(null, null, UrlValidator.ALLOW_ALL_SCHEMES);
System.out.println("SECOND PARTITION TEST\n----------");
String testURLstr1 = "http://www.google.com";
for (int i = 0; i < 5; i++) {
String newString = testURLstr1.substring(0, 3) + "http:/" + testURLstr1.substring(10, 12);
System.out.println(urlVal.isValid(testURLstr1)); // given test -> returns true
testURLstr1 += ".com"; // string to append on
System.out.println(newString);
}
System.out.println("\n");
}
public void testManualTest() {
UrlValidator urlVal = new UrlValidator(null, null, UrlValidator.ALLOW_ALL_SCHEMES);
System.out.println("MANUAL TEST\n----------");
System.out.println(urlVal.isValid("http://www.amazon.com")); // basic given test
System.out.println(urlVal.isValid("http://www.google.com")); // given test -> returns true
System.out.println(urlVal.isValid("http://///www.google.com")); // given test -> returns false
System.out.println(
urlVal.isValid(
"Xhttp://www.google.com")); // first bug found: having value before http still returns
// true.
// bug found by Sarah Cawley
System.out.println("\n");
}
// Test URLs made of numbers and letters
public void testNumbersAndLetters() {
String schemes[] = {"http", "https"};
UrlValidator urlVal = new UrlValidator(schemes);
char[] alphabet = "abcdefghijklmnopqrstuvwxyz1234567890".toCharArray();
for (int i = 0; i < 36; i++) {
String url = "http://www.";
for (int j = 0; j < i + 1; j++) {
url = url + Character.toString(alphabet[j]);
}
url = url + ".com";
if (!urlVal.isValid(url)) {
System.out.println("TEST FAILED: " + url);
}
}
}
// Test URLs made of strange characters
public void testOddities() {
String schemes[] = {"http", "https"};
UrlValidator urlVal = new UrlValidator(schemes);
char[] alphabet = "!@#$%^&*()_+".toCharArray();
for (int i = 0; i < alphabet.length; i++) {
String url = "http://www.";
for (int j = 0; j < i + 1; j++) {
url = url + Character.toString(alphabet[j]);
}
url = url + ".com";
if (urlVal.isValid(url)) {
System.out.println("TEST FAILED: " + url);
}
}
}
/**
* Create set of tests by taking the testUrlXXX arrays and running through all possible
* permutations of their combinations.
*
* @param testObjects Used to create a url.
*/
public void testIsValid(Object[] testObjects, long options) {
UrlValidator urlVal = new UrlValidator(null, null, options);
assertTrue(urlVal.isValid("http://www.google.com"));
assertTrue(urlVal.isValid("http://www.google.com/"));
int statusPerLine = 60;
int printed = 0;
if (printIndex) {
statusPerLine = 6;
}
do {
StringBuffer testBuffer = new StringBuffer();
boolean expected = true;
for (int testPartsIndexIndex = 0;
testPartsIndexIndex < testPartsIndex.length;
++testPartsIndexIndex) {
int index = testPartsIndex[testPartsIndexIndex];
ResultPair[] part = (ResultPair[]) testObjects[testPartsIndexIndex];
testBuffer.append(part[index].item);
expected &= part[index].valid;
}
// System.out.println(testPartsIndex[0]);
String url = testBuffer.toString();
boolean result = urlVal.isValid(url);
if (result == true) System.out.println(url);
assertEquals(url, expected, result);
if (printStatus) {
if (printIndex) {
// System.out.print(testPartsIndextoString());
} else {
if (result == expected) {
System.out.print('.');
} else {
System.out.print('X');
}
}
printed++;
if (printed == statusPerLine) {
System.out.println();
printed = 0;
}
}
} while (incrementTestPartsIndex(testPartsIndex, testObjects));
if (printStatus) {
System.out.println();
}
}
public void testYourFirstPartition() {
// In this partition, I am going for common, expected cases
// I am still trying to find a way to find a bug, though.
UrlValidator urlVal = new UrlValidator(null, null, UrlValidator.ALLOW_ALL_SCHEMES);
System.out.println("FIRST PARTITION TEST\n----------");
String testURLstr1 = "http://www.google.com";
for (int i = 0; i < 5; i++) {
System.out.println(urlVal.isValid(testURLstr1)); // given test -> returns true
testURLstr1 += " "; // string to append on
// ^^^ I believe this is another bug. I believe we can't append on spaces to the end of a
// URL, but this test passes
}
System.out.println(testURLstr1);
System.out.println("\n");
}
public void testIsValidScheme() {
if (printStatus) {
System.out.print("\n testIsValidScheme() ");
}
String[] schemes = {"http", "gopher"};
// UrlValidator urlVal = new UrlValidator(schemes,false,false,false);
UrlValidator urlVal = new UrlValidator(schemes, 0);
for (int sIndex = 0; sIndex < testScheme.length; sIndex++) {
ResultPair testPair = testScheme[sIndex];
boolean result = urlVal.isValidScheme(testPair.item);
assertEquals(testPair.item, testPair.valid, result);
if (printStatus) {
if (result == testPair.valid) {
System.out.print('.');
} else {
System.out.print('X');
}
}
}
if (printStatus) {
System.out.println();
}
}
public void testValidator288() {
UrlValidator validator = new UrlValidator(UrlValidator.ALLOW_LOCAL_URLS);
assertTrue("hostname should validate", validator.isValid("http://hostname"));
assertTrue(
"hostname with path should validate", validator.isValid("http://hostname/test/index.html"));
assertTrue(
"localhost URL should validate", validator.isValid("http://localhost/test/index.html"));
assertFalse(
"first.my-testing should not validate",
validator.isValid("http://first.my-testing/test/index.html"));
assertFalse(
"broke.hostname should not validate",
validator.isValid("http://broke.hostname/test/index.html"));
assertTrue(
"www.apache.org should still validate",
validator.isValid("http://www.apache.org/test/index.html"));
// Turn it off, and check
validator = new UrlValidator(0);
assertFalse("hostname should no longer validate", validator.isValid("http://hostname"));
assertFalse(
"localhost URL should no longer validate",
validator.isValid("http://localhost/test/index.html"));
assertTrue(
"www.apache.org should still validate",
validator.isValid("http://www.apache.org/test/index.html"));
}
public void testYourFithPartition() {
String urlTry;
System.out.println("Testing Query Partition:");
UrlValidator urlVal = new UrlValidator();
assertTrue(validScheme, urlVal.isValidScheme(validScheme));
assertTrue(validAuthority, urlVal.isValidAuthority(validAuthority));
assertTrue(validAuthority + validPort, urlVal.isValidAuthority(validAuthority + validPort));
assertTrue(validPath, urlVal.isValidPath(validPath));
String[] invalidQueryArr = {
"?!!!!@#$#$%^%^&%*&()..",
"?/../",
"?/..//file",
"?/test1//file",
"?///////",
"?456/@",
"?abc",
"?_$",
"?/_#",
"?/^"
};
for (int i = 0; i < invalidQueryArr.length; i++) {
urlTry = validScheme + "://" + validAuthority + validPort + validPath + invalidQueryArr[i];
assertFalse(urlTry + Integer.toString(i), urlVal.isValid(urlTry));
}
String[] validQueryArr = {
"?action=view",
"?action=edit&mode=up",
"?newwindow=1&q=url+query",
"?module_item_id=16435218",
"?some_action=Some_thiNG",
"?1111=22222",
"?royals=world_series_champs",
"?ideas=NoNe",
"?last_ONE=false",
"?LAST_one=true",
};
for (int i = 0; i < validQueryArr.length; i++) {
urlTry = validScheme + "://" + validAuthority + validPort + validPath + validQueryArr[i];
assertTrue(urlTry, urlVal.isValid(urlTry));
}
}
public void testManualTest() {
System.out.println("Manual Tests: ");
UrlValidator urlVal = new UrlValidator();
// Should all return true
assertTrue(urlVal.isValid("http://www.amazon.com"));
assertTrue(urlVal.isValid("http://www.amazon.org:22"));
assertTrue(urlVal.isValid("http://adasd.amazon.com/test1"));
assertTrue(urlVal.isValid("http://www.amazon.zw"));
// Lucky catch.
// Line 446 UrlValidator.java return !QUERY_PATTERN.matcher(query).matches();
// should be return QUERY_PATTERN.matcher(query).matches();
//
assertTrue(urlVal.isValid("http://www.amazon.gov?action=view"));
}
public void testYourFourthPartition() {
String urlTry;
System.out.println("Testing Path Partition:");
UrlValidator urlVal = new UrlValidator();
String[] invalidPathArr = new String[10];
String[] validPathArr = new String[10];
assertTrue(validScheme, urlVal.isValidScheme(validScheme));
assertTrue(validAuthority, urlVal.isValidAuthority(validAuthority));
assertTrue(validAuthority + validPort, urlVal.isValidAuthority(validAuthority + validPort));
// assertTrue(validQuery, urlVal.isValidQuery(validQuery));
invalidPathArr[0] = "/..";
invalidPathArr[1] = "/../";
invalidPathArr[2] = "/..//file";
invalidPathArr[3] = "/test1//file";
invalidPathArr[4] = "///////";
invalidPathArr[5] = "abc";
invalidPathArr[6] = "_$";
invalidPathArr[7] = "/^";
for (int i = 0; i < 8; i++) {
urlTry = validScheme + "://" + validAuthority + validPort + invalidPathArr[i];
assertFalse(urlTry, urlVal.isValid(urlTry));
}
validPathArr[0] = "/test1";
validPathArr[1] = "/t123";
validPathArr[2] = "/$23";
validPathArr[3] = "/test1/";
validPathArr[4] = "/test1/file";
validPathArr[5] = "/java/java_object_classes";
validPathArr[6] = "/courses/1555028/assignments/6594488";
validPathArr[7] = "/wiki/Uniform_Resource_Identifier";
validPathArr[8] = "/search";
validPathArr[9] = "/r/cscareerquestions";
for (int i = 0; i < 10; i++) {
urlTry = validScheme + "://" + validAuthority + validPort + validPathArr[i];
assertTrue(urlTry, urlVal.isValid(urlTry));
}
}
public void testYourSecondPartition() {
System.out.println("Testing Authority Partition:");
UrlValidator urlVal = new UrlValidator();
String[] invalidAuthorityArr = new String[10];
String[] validAuthorityArr = new String[10];
assertTrue(urlVal.isValidScheme("http"));
assertTrue(urlVal.isValidAuthority(validAuthority + validPort));
assertTrue(urlVal.isValidPath(validPath));
// assertTrue(urlVal.isValidQuery(validQuery));
invalidAuthorityArr[0] = "256.256.256.256";
invalidAuthorityArr[1] = "1.2.3.4.5";
invalidAuthorityArr[2] = ".1.2.3.4";
invalidAuthorityArr[3] = "go.a1a";
invalidAuthorityArr[4] = "go.1aa";
invalidAuthorityArr[5] = ".aaa";
invalidAuthorityArr[6] = "aaa";
invalidAuthorityArr[7] = "aaa.";
invalidAuthorityArr[8] = "1.2.3";
invalidAuthorityArr[9] = "";
for (int i = 0; i < 10; i++) {
String urlTry = validScheme + invalidAuthorityArr[i] + validPort + validPath + validQuery;
System.out.println(urlTry);
assertFalse(urlVal.isValid(urlTry));
}
validAuthorityArr[0] = "www.google.com";
validAuthorityArr[1] = "google.com";
validAuthorityArr[2] = "google.org";
validAuthorityArr[3] = "255.com";
validAuthorityArr[4] = "google.gov";
validAuthorityArr[5] = "google.edu";
for (int i = 0; i < 6; i++) {
String urlTry = validScheme + validAuthorityArr[i] + validPort + validPath;
assertTrue(urlTry, urlVal.isValid(urlTry));
}
}
//////////////////////// bad query validator makes all these fail. Comment out + validQuery in
// for loops to check for other errors
public void testYourFirstPartition() {
System.out.println("Testing Scheme Partition:");
UrlValidator urlVal = new UrlValidator();
String[] validSchemeArr = new String[3];
String[] invalidSchemeArr = new String[10];
// Check to make sure the pieces we aren't testing are valid. If false exit tests
assertTrue(urlVal.isValidAuthority(validAuthority + validPort));
assertTrue(urlVal.isValidAuthority(validAuthority));
assertTrue(urlVal.isValidPath(validPath));
// assertTrue(urlVal.isValidQuery(validQuery));
validSchemeArr[0] = "http://"; // Known valid schemes
validSchemeArr[1] = "ftp://";
validSchemeArr[2] = "https://";
// Check known valid Schemes
for (int i = 0; i < 3; i++) {
String urlTry = validSchemeArr[i] + validAuthority + validPort + validPath;
assertTrue(urlTry, urlVal.isValid(urlTry));
}
// Invalid schmes
invalidSchemeArr[0] = "https";
invalidSchemeArr[1] = "data://";
invalidSchemeArr[2] = "zzzzz://";
invalidSchemeArr[3] = "ftp:/";
invalidSchemeArr[4] = "ftp";
invalidSchemeArr[5] = "ftp:://";
invalidSchemeArr[6] = "ftp:";
invalidSchemeArr[7] = "https:///";
invalidSchemeArr[8] = "https:$/";
invalidSchemeArr[9] = "https//:";
for (int i = 0;
i < 10;
i++) { // Same as last for loop but using invalid scheme and checking to see if ends up
// being true
assertFalse(
urlVal.isValid(
invalidSchemeArr[i] + validAuthority + validPort + validPath + validQuery));
}
}
public void testYourThirdPartition() {
System.out.println("Testing Port Partition:");
UrlValidator urlVal = new UrlValidator();
String urlTry;
assertTrue(urlVal.isValidScheme(validScheme));
assertTrue(urlVal.isValidAuthority(validAuthority));
assertTrue(urlVal.isValidPath(validPath));
// assertTrue(urlVal.isValidQuery(validQuery));
String[] invalidPortArr = {
":123456",
":655365",
":1b3",
":b21",
":.11111",
":ljljl",
":-1",
":-200",
":-b.",
":1234567",
":-0"
};
for (int i = 0; i < invalidPortArr.length; i++) {
urlTry = validScheme + "://" + validAuthority + invalidPortArr[i] + validPath;
assertFalse(urlTry, urlVal.isValid(urlTry));
}
String[] validPortArr = {
":22", ":65535", ":0", ":65534", ":1", ":12", ":123", ":1234", ":12345", ":11111",
};
for (int i = 0; i < validPortArr.length; i++) {
urlTry = validScheme + "://" + validAuthority + validPortArr[i] + validPath;
assertTrue(urlTry, urlVal.isValid(urlTry));
}
}
public void testBug2() {
UrlValidator validator = new UrlValidator();
validator.isValid("http://0.0.0.0:80/test1?action=view true");
}
// Check URLs by IP. Check URLs of
// one, two, three, four, and five octets
public void testIPs() {
String url;
String schemes[] = {"http", "https"};
UrlValidator urlVal = new UrlValidator(schemes);
int max_num = 300;
System.out.println("Testing one octet...");
for (int a = 0; a < max_num; a++) {
url = "http://" + Integer.toString(a);
if (urlVal.isValid(url)) {
System.out.println("TEST Failed: " + url);
}
}
System.out.println("Testing two octets...");
for (int a = 0; a < max_num; a++) {
for (int b = 0; b < max_num; b++) {
url = "http://" + Integer.toString(a) + "." + Integer.toString(b);
if (urlVal.isValid(url)) {
System.out.println("TEST Failed: " + url);
}
}
}
System.out.println("Testing three octets...");
for (int a = 0; a < max_num; a++) {
for (int b = 0; b < max_num; b++) {
for (int c = 0; c < max_num; c++) {
url =
"http://"
+ Integer.toString(a)
+ "."
+ Integer.toString(b)
+ "."
+ Integer.toString(c);
if (urlVal.isValid(url)) {
System.out.println("TEST Failed: " + url);
}
}
}
}
System.out.println("Testing four octets...");
for (int a = 0; a < max_num; a++) {
for (int b = 0; b < max_num; b++) {
for (int c = 0; c < max_num; c++) {
for (int d = 0; d < max_num; d++) {
url =
"http://"
+ Integer.toString(a)
+ "."
+ Integer.toString(b)
+ "."
+ Integer.toString(c)
+ "."
+ Integer.toString(d);
// System.out.println(url);
if (a > 255 || b > 255 || c > 255 || d > 255) {
// System.out.println(url);
if (urlVal.isValid(url)) {
System.out.println("TEST FAILED: " + url);
}
} else {
if (!urlVal.isValid(url)) {
System.out.println("TEST FAILED" + url);
}
}
}
}
}
}
System.out.println("Testing five octets...");
for (int a = 0; a < max_num; a++) {
for (int b = 0; b < max_num; b++) {
for (int c = 0; c < max_num; c++) {
for (int d = 0; d < max_num; d++) {
for (int e = 0; e < max_num; e++) {
url =
"http://"
+ Integer.toString(a)
+ "."
+ Integer.toString(b)
+ "."
+ Integer.toString(c)
+ "."
+ Integer.toString(d)
+ "."
+ Integer.toString(e);
if (urlVal.isValid(url)) {
System.out.println("TEST FAILED" + url);
}
}
}
}
}
}
}
// Test queries by assembling different variations of query parameters
public void testParams() {
String param_list[] = {"action=true", "data=somedata", "username=nayara", ""};
String schemes[] = {"https", "http"};
String domains[] = {"www.amazon", "www.google", "www.bing"};
String suffixes[] = {".com", ".net", ".org"};
String subdir[] = {"test", null};
String url;
UrlValidator urlVal = new UrlValidator(schemes);
String scheme, domain, suffix, dir, param;
for (int a = 0; a < 2; a++) {
scheme = schemes[a];
for (int b = 0; b < 3; b++) {
domain = domains[b];
for (int c = 0; c < 3; c++) {
suffix = suffixes[c];
for (int d = 0; d < 2; d++) {
for (int e = 0; e < 4; e++) {
param = param_list[e];
if (subdir[d] != null) {
url = scheme + "://" + domain + suffix + "/" + subdir[d] + "?" + param;
} else {
url = scheme + "://" + domain + suffix + "?" + param;
}
if (!urlVal.isValid(url)) {
System.out.println("TEST Failed: " + url);
}
}
}
}
}
}
for (int a = 0; a < 2; a++) {
scheme = schemes[a];
for (int b = 0; b < 3; b++) {
domain = domains[b];
for (int c = 0; c < 3; c++) {
suffix = suffixes[c];
for (int d = 0; d < 2; d++) {
if (subdir[d] != null) {
url = scheme + "://" + domain + suffix + "/" + subdir[d] + "?";
} else {
url = scheme + "://" + domain + suffix + "?";
}
url = url + param_list[0] + "&" + param_list[1] + "&" + param_list[2];
if (!urlVal.isValid(url)) {
System.out.println("TEST Failed: " + url);
}
}
}
}
}
// Perform a few more manual tests
url = "http://www.a.com?action=true";
if (!urlVal.isValid(url)) {
System.out.println("TEST Failed: " + url);
}
url = "http://www.google.com??";
if (urlVal.isValid(url)) {
System.out.println("TEST Failed: " + url);
}
url = "http://www.google.com?action=true?";
if (urlVal.isValid(url)) {
System.out.println("TEST Failed: " + url);
}
url = "http://www.google.com?action=?";
if (urlVal.isValid(url)) {
System.out.println("TEST Failed: " + url);
}
}
public void testBug1() {
// http://www.google.com:80/test1?action=view true
UrlValidator validator = new UrlValidator();
validator.isValid("http://www.google.com:80/test1?action=view true");
}
public void testValidator218() {
UrlValidator validator = new UrlValidator(UrlValidator.ALLOW_2_SLASHES);
assertTrue(
"parentheses should be valid in URLs",
validator.isValid("http://somewhere.com/pathxyz/file(1).html"));
}
public void testManualTest() {
UrlValidator urlVal = new UrlValidator(null, null, UrlValidator.ALLOW_ALL_SCHEMES);
System.out.println("*************************Start Manual*************************");
System.out.println("1: " + urlVal.isValid("https://www.amazon.com"));
System.out.println("2: " + urlVal.isValid("http://www.amazon.com"));
System.out.println("3: " + urlVal.isValid("www.amazon.com"));
System.out.println("4: " + urlVal.isValid("amazon.com"));
System.out.println("5: " + urlVal.isValid("amazon"));
System.out.println("6: " + urlVal.isValid(" "));
System.out.println("7: " + urlVal.isValid("https://www.google.com"));
System.out.println("8: " + urlVal.isValid("http://www.google.com"));
System.out.println("9: " + urlVal.isValid("www.google.com"));
System.out.println("10: " + urlVal.isValid("google.com"));
System.out.println("11: " + urlVal.isValid("google"));
System.out.println("12: " + urlVal.isValid("https://www.example.com"));
System.out.println("13: " + urlVal.isValid("http://www.example.com"));
System.out.println("14: " + urlVal.isValid("http://example.com"));
System.out.println("15: " + urlVal.isValid("www.example.com"));
System.out.println("16: " + urlVal.isValid("example.com"));
System.out.println("17: " + urlVal.isValid("example"));
System.out.println("18: " + urlVal.isValid("http://www.iana.org/domains/reserved"));
System.out.println("19: " + urlVal.isValid("http://www.example.com/file1/file2"));
System.out.println("20: " + urlVal.isValid("ftp://www.example.com"));
System.out.println("21: " + urlVal.isValid("hps://www.wikipedia.org"));
System.out.println("22: " + urlVal.isValid("http://0.0.0.0:0/test1"));
System.out.println("23: " + urlVal.isValid("http://0.0.0.0/test1"));
System.out.println("24: " + urlVal.isValid("http://0.0.0.0:100/test1"));
System.out.println("25: " + urlVal.isValid("http://0.0.0.0:1000/test1"));
System.out.println(
"26: "
+ urlVal.isValid(
"http://en.wikipedia.org/w/index.php?title=Hantavirus&action=edit§ion=4"));
System.out.println("27: " + urlVal.isValid("http://nwmotion.loc"));
System.out.println("************************* End Manual *************************");
}
public void testValidator276() {
// file:// isn't allowed by default
UrlValidator validator = new UrlValidator();
assertTrue(
"http://apache.org/ should be allowed by default",
validator.isValid("http://www.apache.org/test/index.html"));
assertFalse(
"file:///c:/ shouldn't be allowed by default", validator.isValid("file:///C:/some.file"));
assertFalse(
"file:///c:\\ shouldn't be allowed by default", validator.isValid("file:///C:\\some.file"));
assertFalse(
"file:///etc/ shouldn't be allowed by default", validator.isValid("file:///etc/hosts"));
assertFalse(
"file://localhost/etc/ shouldn't be allowed by default",
validator.isValid("file://localhost/etc/hosts"));
assertFalse(
"file://localhost/c:/ shouldn't be allowed by default",
validator.isValid("file://localhost/c:/some.file"));
// Turn it on, and check
// Note - we need to enable local urls when working with file:
validator = new UrlValidator(new String[] {"http", "file"}, UrlValidator.ALLOW_LOCAL_URLS);
assertTrue(
"http://apache.org/ should be allowed by default",
validator.isValid("http://www.apache.org/test/index.html"));
assertTrue("file:///c:/ should now be allowed", validator.isValid("file:///C:/some.file"));
// Currently, we don't support the c:\ form
assertFalse("file:///c:\\ shouldn't be allowed", validator.isValid("file:///C:\\some.file"));
assertTrue("file:///etc/ should now be allowed", validator.isValid("file:///etc/hosts"));
assertTrue(
"file://localhost/etc/ should now be allowed",
validator.isValid("file://localhost/etc/hosts"));
assertTrue(
"file://localhost/c:/ should now be allowed",
validator.isValid("file://localhost/c:/some.file"));
// These are never valid
assertFalse(
"file://c:/ shouldn't ever be allowed, needs file:///c:/",
validator.isValid("file://C:/some.file"));
assertFalse(
"file://c:\\ shouldn't ever be allowed, needs file:///c:/",
validator.isValid("file://C:\\some.file"));
}
