package com.limegroup.gnutella.altlocs;
import java.io.IOException;
import java.net.URL;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;
import junit.framework.Test;
import com.limegroup.gnutella.Endpoint;
import com.limegroup.gnutella.GUID;
import com.limegroup.gnutella.HugeTestUtils;
import com.limegroup.gnutella.PushEndpoint;
import com.limegroup.gnutella.RemoteFileDesc;
import com.limegroup.gnutella.URN;
import com.limegroup.gnutella.http.HTTPConstants;
import com.limegroup.gnutella.messages.QueryReply;
import com.limegroup.gnutella.settings.ConnectionSettings;
import com.limegroup.gnutella.util.IpPort;
import com.limegroup.gnutella.util.IpPortImpl;
import com.limegroup.gnutella.util.IpPortSet;
import com.limegroup.gnutella.util.PrivilegedAccessor;
/**
* This class tests the methods of the <tt>AlternateLocation</tt> class.
*/
public final class AlternateLocationTest extends com.limegroup.gnutella.util.BaseTestCase {
private static final String[] equalLocs = {
"http://200.30.1.02:6352" + HTTPConstants.URI_RES_N2R +
"urn:sha1:PLSTHIPQGSSZTS5FJUPAKUZWUGYQYPFB",
"http://200.30.1.02:6352" + HTTPConstants.URI_RES_N2R +
"urn:sha1:PLSTHIPQGSSZTS5FJUPAKUZWUGYQYPFB",
};
private static final String[] VALID_TIMESTAMPS = {
"2002-04-30",
"2002-04-30T08:31Z",
"2002-04-30T08:31:20Z",
"2002-04-30T08:31:21.45Z",
"2002-04-30T00:31:21.45Z",
"2002-04-30T23:31:21.45Z",
"2002-04-30T23:00:21.45Z",
"2002-04-30T23:59:21.45Z",
"2002-04-30T23:31:00.45Z",
"2002-04-30T23:31:59.45Z",
"2002-01-30T23:31:59.45Z",
"2002-01-01T23:31:59.45Z",
"2002-01-31T23:31:59.45Z"
};
private static final String[] INVALID_TIMESTAMPS = {
"2002-04",
"2002-04-30T",
"2002-04-30T08:31:21.45TZD",
"2002-04-40T08:31:21.45Z",
"2002-13-30T08:31:21.45Z",
"2002-04-30T08:31:21.45",
"2002-04-30T08:31:60Z",
"2002-04-30T08:60:21Z",
"2002-04-30T24:31:21Z",
"2002-04-32T08:31:21Z",
"2002-00-00T08:31:21Z"
};
public AlternateLocationTest(String name) {
super(name);
}
public static Test suite() {
return buildTestSuite(AlternateLocationTest.class);
}
public static void main(String[] args) {
junit.textui.TestRunner.run(suite());
}
public void setUp() {
ConnectionSettings.LOCAL_IS_PRIVATE.setValue(true);
}
/**
* Tests the constructor that takes a URL as an argument to make sure it
* succeeds when it should.
*/
public void testUrlUrnConstructorForSuccess() throws Exception {
for(int i=0; i<HugeTestUtils.URNS.length; i++) {
URN urn = URN.createSHA1Urn(HugeTestUtils.VALID_URN_STRINGS[i]);
URL url = new URL("http", HugeTestUtils.HOST_STRINGS[i], 6346,
HTTPConstants.URI_RES_N2R+
HugeTestUtils.URNS[i].httpStringValue());
AlternateLocation al = HugeTestUtils.create(url);
}
}
/**
* Tests the constructor that takes a string as an argument to make sure it
* succeeds when it should.
*/
public void testStringUrnConstructorForSuccess() throws Exception {
for(int i=0; i<HugeTestUtils.URNS.length; i++) {
URN urn = URN.createSHA1Urn(HugeTestUtils.VALID_URN_STRINGS[i]);
String url = "http://"+HugeTestUtils.HOST_STRINGS[i]+":6346"+
HTTPConstants.URI_RES_N2R+
HugeTestUtils.URNS[i].httpStringValue();
AlternateLocation al =
AlternateLocation.create(url);
}
}
/**
* Tests the constructor that takes a URL as an argument to make sure it fails when
* there's no SHA1.
*/
public void testUrlUrnConstructorForFailure() {
try {
for(int i=0; i<HugeTestUtils.URNS.length; i++) {
URL url = new URL("http", HugeTestUtils.HOST_STRINGS[i], 6346, "/test.htm");
AlternateLocation al = HugeTestUtils.create(url);
fail("AlternateLocation constructor should have thrown an exception");
}
} catch(IOException e) {
// this also catches MalformedURLException
}
}
/**
* Tests the constructor that takes a URL as an argument to make sure it fails when
* there's no SHA1.
*/
public void testStringUrnConstructorForFailure() {
try {
for(int i=0; i<HugeTestUtils.URNS.length; i++) {
String url = "http://" +HugeTestUtils.HOST_STRINGS[i]+":6346/test.htm";
AlternateLocation al =
AlternateLocation.create(url);
fail("AlternateLocation constructor should have thrown an exception");
}
} catch(IOException e) {
// this also catches MalformedURLException
}
}
/**
* Tests the constructor that creates an alternate location from a remote
* file desc.
*/
public void testRemoteFileDescConstructor() throws Exception {
for(int i=0; i<HugeTestUtils.URNS.length; i++) {
RemoteFileDesc rfd =
new RemoteFileDesc("www.limewire.org", 6346, 10, HTTPConstants.URI_RES_N2R+
HugeTestUtils.URNS[i].httpStringValue(), 10,
GUID.makeGuid(), 10, true, 2, true, null,
HugeTestUtils.URN_SETS[i],
false,false,"",0,null, -1);
// just make sure this doesn't throw an exception
AlternateLocation loc = AlternateLocation.create(rfd);
assertFalse(loc instanceof PushAltLoc);
}
RemoteFileDesc rfd =
new RemoteFileDesc("127.0.2.1", 6346, 10, HTTPConstants.URI_RES_N2R+
HugeTestUtils.URNS[0].httpStringValue(), 10,
GUID.makeGuid(), 10, true, 2, true, null,
HugeTestUtils.URN_SETS[0],
false,false,"",0,null, -1);
AlternateLocation.create(rfd);
try {
AlternateLocation.create((RemoteFileDesc)null);
fail("should have thrown a null pointer");
} catch(NullPointerException e) {
// this is expected
}
IpPort ppi = new IpPortImpl("1.2.3.4",6346);
Set proxies = new IpPortSet();
proxies.add(ppi);
PushEndpoint pe = new PushEndpoint(GUID.makeGuid(),proxies);
//test an rfd with push proxies
RemoteFileDesc fwalled = new RemoteFileDesc("1.2.3.4",5,10,HTTPConstants.URI_RES_N2R+
HugeTestUtils.URNS[0].httpStringValue(), 10,
GUID.makeGuid(), 10, true, 2, true, null,
HugeTestUtils.URN_SETS[0],
false,true,"",0,proxies,-1);
AlternateLocation loc = AlternateLocation.create(fwalled);
assertTrue(loc instanceof PushAltLoc);
PushAltLoc push = (PushAltLoc)loc;
assertEquals("1.2.3.4",push.getPushAddress().getAddress());
assertEquals(0, push.supportsFWTVersion());
// test rfd with push proxies, external address that can do FWT
RemoteFileDesc FWTed = new RemoteFileDesc("1.2.3.4",5,10,HTTPConstants.URI_RES_N2R+
HugeTestUtils.URNS[0].httpStringValue(), 10,
GUID.makeGuid(), 10, true, 2, true, null,
HugeTestUtils.URN_SETS[0],
false,true,"",0,proxies,-1,1);
loc = AlternateLocation.create(FWTed);
assertTrue(loc instanceof PushAltLoc);
push = (PushAltLoc)loc;
assertEquals("1.2.3.4",push.getPushAddress().getAddress());
assertGreaterThan(0, push.supportsFWTVersion());
assertEquals(5,push.getPushAddress().getPort());
}
/**
* Tests the factory method that creates a RemoteFileDesc from an alternate
* location.
*/
public void testCreateRemoteFileDesc() throws Exception{
for(int i=0; i<HugeTestUtils.UNEQUAL_SHA1_LOCATIONS.length; i++) {
DirectAltLoc al = (DirectAltLoc) HugeTestUtils.UNEQUAL_SHA1_LOCATIONS[i];
RemoteFileDesc rfd = al.createRemoteFileDesc(10);
assertEquals("SHA1s should be equal", al.getSHA1Urn(), rfd.getSHA1Urn());
assertEquals("hosts should be equals",al.getHost().getAddress(),
rfd.getHost());
assertEquals("ports should be equals",al.getHost().getPort(),
rfd.getPort());
}
IpPort ppi = new IpPortImpl("1.2.3.4",6346);
Set proxies = new HashSet();
proxies.add(ppi);
PushEndpoint pe = new PushEndpoint(GUID.makeGuid(),proxies);
//test an rfd with push proxies
RemoteFileDesc fwalled = new RemoteFileDesc("1.2.3.4",5,10,HTTPConstants.URI_RES_N2R+
HugeTestUtils.URNS[0].httpStringValue(), 10,
GUID.makeGuid(), 10, true, 2, true, null,
HugeTestUtils.URN_SETS[0],
false,true,"",0,proxies,-1);
AlternateLocation loc = AlternateLocation.create(fwalled);
RemoteFileDesc other = loc.createRemoteFileDesc(3);
assertEquals("1.2.3.4",other.getHost());
assertEquals(5,other.getPort());
assertEquals(fwalled.getClientGUID(),other.getClientGUID());
assertEquals(fwalled.getPushAddr(),other.getPushAddr());
}
public void testCloningPushLocs() throws Exception {
IpPort ppi = new IpPortImpl("1.2.3.4",6346);
Set proxies = new HashSet();
proxies.add(ppi);
PushEndpoint pe = new PushEndpoint(GUID.makeGuid(),proxies);
//test an rfd with push proxies
RemoteFileDesc fwalled = new RemoteFileDesc("127.0.0.1",6346,10,HTTPConstants.URI_RES_N2R+
HugeTestUtils.URNS[0].httpStringValue(), 10,
GUID.makeGuid(), 10, true, 2, true, null,
HugeTestUtils.URN_SETS[0],
false,true,"",0,proxies,-1);
AlternateLocation loc = AlternateLocation.create(fwalled);
assertTrue(loc instanceof PushAltLoc);
AlternateLocation loc2 = loc.createClone();
assertTrue(loc2 instanceof PushAltLoc);
assertEquals(loc,loc2);
Map m = (Map) PrivilegedAccessor.getValue(PushEndpoint.class,"GUID_PROXY_MAP");
m.clear();
}
/**
* Tests the constructor that only takes a string argument for
* valid alternate location strings that include timestamps.
*/
public void testStringConstructorForTimestampedLocs() throws Exception {
try {
for(int i=0; i<HugeTestUtils.VALID_TIMESTAMPED_LOCS.length; i++) {
AlternateLocation al =
AlternateLocation.create(HugeTestUtils.VALID_TIMESTAMPED_LOCS[i]);
}
} catch(IOException iox) {
fail("failed to create locaction with timestamp string");
}
}
/**
* Tests the constructor that only takes a string argument, but in this
* case the strings are valid alternate locations, but they don't have
* timestamps.
*/
public void testStringConstructorForNotTimestampedLocs() throws Exception {
for(int i=0; i<HugeTestUtils.VALID_NONTIMESTAMPED_LOCS.length; i++) {
try {
AlternateLocation al =
AlternateLocation.create(HugeTestUtils.VALID_NONTIMESTAMPED_LOCS[i]);
} catch(IOException e) {
fail("failed on loc: "+HugeTestUtils.VALID_NONTIMESTAMPED_LOCS[i], e);
}
}
}
/**
* Tests invalid alternate location strings to make sure they fail.
*/
public void testStringConstructorForInvalidLocs() {
try {
for(int i=0; i<HugeTestUtils.INVALID_LOCS.length; i++) {
AlternateLocation al =
AlternateLocation.create(HugeTestUtils.INVALID_LOCS[i]);
fail("alternate location string should not have been accepted");
}
} catch(IOException e) {
// the exception is excpected in this case
}
}
public void testConstructorForBadPorts() throws Exception {
try {
for(int i=0; i<HugeTestUtils.BAD_PORT_URLS.length; i++) {
AlternateLocation al = HugeTestUtils.create(HugeTestUtils.BAD_PORT_URLS[i]);
fail("alternate location string should not have been accepted: "+
HugeTestUtils.BAD_PORT_URLS[i]);
}
} catch(IOException e) {
// this is what we're expecting
}
}
/**
* Tests the location/urn constructor for success.
*/
public void testStringUrnConstructor() throws Exception {
ConnectionSettings.LOCAL_IS_PRIVATE.setValue(false);
URN urn =
URN.createSHA1Urn("urn:sha1:ULSTTIPQGSSZTS5FJUPAKUZWUGYQYPTE");
// First test with old-style locs.
for(int i=0; i<HugeTestUtils.VALID_NONTIMESTAMPED_LOCS.length; i++) {
AlternateLocation al = AlternateLocation.create(
HugeTestUtils.VALID_NONTIMESTAMPED_LOCS[i], urn);
}
// Now make sure that the URN-mismatch works
urn = URN.createSHA1Urn("urn:sha1:ULSTTIPQGSSZTS5FJUPAKUZWUGYQYPTD");
for(int i=0; i<HugeTestUtils.VALID_NONTIMESTAMPED_LOCS.length; i++) {
try {
AlternateLocation al = AlternateLocation.create(
HugeTestUtils.VALID_NONTIMESTAMPED_LOCS[i], urn);
fail("IOException expected");
} catch(IOException expected) {}
}
// Now try the new-style values
for(int i = 1; i < 254; i++) {
String ip = i+"."+(i % 2)+"."+(i % 25)+"."+(i % 100);
DirectAltLoc al = (DirectAltLoc) AlternateLocation.create(ip + ":50", urn);
IpPort ep = al.getHost();
assertEquals(ip, ep.getAddress());
assertEquals(50, ep.getPort());
assertEquals(urn, al.getSHA1Urn());
}
// Try without a port.
for(int i = 1; i < 254; i++) {
String ip = i+"."+(i % 2)+"."+(i % 25)+"."+(i % 100);
DirectAltLoc al = (DirectAltLoc)AlternateLocation.create(ip, urn);
IpPort ep = al.getHost();
assertEquals(ip, ep.getAddress());
assertEquals(6346, ep.getPort());
assertEquals(urn, al.getSHA1Urn());
}
// Try with bad values.
for(int i = 1; i < 254; i++) {
try {
String ip = i+"."+(i % 2)+"."+(i % 25)+"."+(i % 100)+".1";
AlternateLocation al =
AlternateLocation.create(ip + ":50", urn);
fail("IOException expected");
} catch(IOException expected) {}
}
try {
AlternateLocation.create("0.1.2.3", urn);
fail("IOException expected");
} catch(IOException expected) {}
try {
AlternateLocation.create("1.2.3.4/25", urn);
fail("IOException expected");
} catch(IOException expected) {}
try {
AlternateLocation.create("limewire.org", urn);
fail("IOException expected");
} catch(IOException expected) {}
//try some firewalled locs
GUID clientGUID = new GUID(GUID.makeGuid());
String httpString=clientGUID.toHexString()+";1.2.3.4:15;1.2.3.5:16";
PushAltLoc pal = (PushAltLoc)AlternateLocation.create(httpString,urn);
assertTrue(Arrays.equals(
clientGUID.bytes(),pal.getPushAddress().getClientGUID()));
assertEquals(2,pal.getPushAddress().getProxies().size());
//try some valid push proxies, some invalid ones
clientGUID = new GUID(GUID.makeGuid());
httpString=clientGUID.toHexString()+";1.2.3.4:15;1.2.3.5:16";
pal = (PushAltLoc) AlternateLocation.create(httpString+";0.1.2.3:100000;1.2.3.6:17",urn);
assertTrue(Arrays.equals(
clientGUID.bytes(),pal.getPushAddress().getClientGUID()));
assertEquals(3,pal.getPushAddress().getProxies().size());
//HashSets do not guarantee order so the resulting http string
//may contain the proxies in different order
assertNotEquals(-1,pal.httpStringValue().indexOf(clientGUID.toHexString()));
assertNotEquals(-1,pal.httpStringValue().indexOf("1.2.3.4:15"));
assertNotEquals(-1,pal.httpStringValue().indexOf("1.2.3.5:16"));
//try some valid push proxies and an empty one
clientGUID = new GUID(GUID.makeGuid());
httpString=clientGUID.toHexString()+";1.2.3.4:15;1.2.3.5:16";
pal = (PushAltLoc) AlternateLocation.create(httpString+";;1.2.3.6:17",urn);
assertTrue(Arrays.equals(
clientGUID.bytes(),pal.getPushAddress().getClientGUID()));
assertEquals(3,pal.getPushAddress().getProxies().size());
//try an altloc with no push proxies
clientGUID = new GUID(GUID.makeGuid());
pal = (PushAltLoc) AlternateLocation.create(clientGUID.toHexString()+";",urn);
// try skipping invalid ip:port strings
pal = (PushAltLoc) AlternateLocation.create(
clientGUID.toHexString()+";"+ "1.2.3.4/:12",urn);
assertTrue(pal.getPushAddress().getProxies().isEmpty());
//try some invalid ones
try {
pal = (PushAltLoc) AlternateLocation.create("asdf2345dgalshlh",urn);
fail("created altloc from garbage");
}catch(IOException expected) {}
try {
pal = (PushAltLoc) AlternateLocation.create("",urn);
fail("created altloc from empty string");
}catch(IOException expected) {}
try {
pal = (PushAltLoc) AlternateLocation.create(null,urn);
fail("created altloc from null string");
}catch(IOException expected) {}
}
public void testDemotedEquals() throws Exception {
AlternateLocation loc1 = AlternateLocation.create(equalLocs[0]);
AlternateLocation loc2 = AlternateLocation.create(equalLocs[0]);
assertEquals("locations should be equal", loc1, loc2);
loc2.demote();
assertEquals("locations should be equal", loc1, loc2);
}
public void testCompareTo() throws Exception {
TreeSet set = new TreeSet();
AlternateLocation direct1 = AlternateLocation.create(equalLocs[0]);
AlternateLocation direct2 = AlternateLocation.create(equalLocs[0]);
set.add(direct1);
assertTrue(set.contains(direct2));
direct2.increment();
assertFalse(set.contains(direct2));
assertLessThan(0,direct1.compareTo(direct2));
set.remove(direct1);
direct1.demote();
assertGreaterThan(0,direct1.compareTo(direct2));
direct1.promote();
assertLessThan(0,direct1.compareTo(direct2));
// try some push altlocs
GUID clientGUID = new GUID(GUID.makeGuid());
String httpString=clientGUID.toHexString()+";1.2.3.4:15;1.2.3.5:16";
URN urn =
URN.createSHA1Urn("urn:sha1:ULSTTIPQGSSZTS5FJUPAKUZWUGYQYPTE");
AlternateLocation push1 = AlternateLocation.create(httpString,urn);
AlternateLocation push2 = AlternateLocation.create(httpString,urn);
assertTrue(push1.equals(push2));
assertEquals(0,push1.compareTo(push2));
push2.increment();
assertLessThan(0,push1.compareTo(push2));
// calling demote() does not affect push locs
push1.demote();
assertLessThan(0,push1.compareTo(push2));
// comparing the two types of altlocs is predictable if their count
// values are different
assertGreaterThan(0,direct2.compareTo(push1));
// it is not easily predictable if they are the same
assertNotEquals(0,direct2.compareTo(push2));
}
/**
* Test the equals method.
*/
public void testAlternateLocationEquals() throws Exception {
for(int i=0; i<equalLocs.length; i++) {
AlternateLocation curLoc = AlternateLocation.create(equalLocs[i]);
for(int j=0; j<equalLocs.length; j++) {
AlternateLocation newLoc=AlternateLocation.create(equalLocs[j]);
assertEquals("locations should be equal", curLoc, newLoc);
}
}
TreeMap timeStampedAltLocs0 = new TreeMap();
TreeMap testMap = new TreeMap();
for(int i=0; i<HugeTestUtils.VALID_TIMESTAMPED_LOCS.length; i++) {
AlternateLocation al0 =
AlternateLocation.create(HugeTestUtils.VALID_TIMESTAMPED_LOCS[i]);
AlternateLocation al1 =
AlternateLocation.create(HugeTestUtils.VALID_TIMESTAMPED_LOCS[i]);
timeStampedAltLocs0.put(al0, al0);
testMap.put(al1, al1);
}
//assertEquals("maps should be equal", timeStampedAltLocs0, testMap);
TreeMap timeStampedAltLocs1 = new TreeMap(timeStampedAltLocs0);
Iterator iter0 = timeStampedAltLocs0.values().iterator();
Iterator iter1 = timeStampedAltLocs1.values().iterator();
while(iter0.hasNext()) {
AlternateLocation al0 = (AlternateLocation)iter0.next();
AlternateLocation al1 = (AlternateLocation)iter1.next();
assertEquals("alternate location values should be equal", al0, al1);
}
Iterator iter20 = timeStampedAltLocs0.keySet().iterator();
Iterator iter21 = timeStampedAltLocs1.keySet().iterator();
while(iter20.hasNext()) {
AlternateLocation al0 = (AlternateLocation)iter20.next();
AlternateLocation al1 = (AlternateLocation)iter21.next();
assertEquals("alternate location keys should be equal", al0, al1);
}
Iterator iter30 = timeStampedAltLocs0.entrySet().iterator();
Iterator iter31 = timeStampedAltLocs1.entrySet().iterator();
while(iter20.hasNext()) {
Map.Entry al0 = (Map.Entry)iter30.next();
Map.Entry al1 = (Map.Entry)iter31.next();
assertEquals("alternate location entries should be equal", al0, al1);
}
assertEquals("sizes should be equal", timeStampedAltLocs1.size(),
timeStampedAltLocs0.size());
Iterator i = timeStampedAltLocs0.entrySet().iterator();
while (i.hasNext()) {
Map.Entry e = (Map.Entry) i.next();
Object key = e.getKey();
Object value = e.getValue();
if (value == null) {
if (!(timeStampedAltLocs1.get(key)==null &&
timeStampedAltLocs1.containsKey(key)))
assertTrue("key not found", false);
} else {
if (!value.equals(timeStampedAltLocs1.get(key)))
assertTrue("value not found", false);
}
}
// the following does not work for some reason, but I'm not at all sure
// why, especially considering that all of the above code passes the
// assertions??
//assertEquals("maps should be equal: "+timeStampedAltLocs0, timeStampedAltLocs1);
}
/**
* Tests the compareTo method of the AlternateLocation class.
*/
public void testAlternateLocationCompareTo() throws Exception {
for(int i=0; i<equalLocs.length; i++) {
AlternateLocation curLoc =
AlternateLocation.create(equalLocs[i]);
for(int j=0; j<equalLocs.length; j++) {
AlternateLocation newLoc =
AlternateLocation.create(equalLocs[j]);
int z = curLoc.compareTo(newLoc);
assertEquals("locations should be equal", 0, z);
}
}
// make sure that alternate locations with the same timestamp and
// different URLs are not considered the same
for(int i=0; i<(HugeTestUtils.VALID_NONTIMESTAMPED_LOCS.length-1); i++) {
String loc0 = HugeTestUtils.VALID_NONTIMESTAMPED_LOCS[i];
String loc1 = HugeTestUtils.VALID_NONTIMESTAMPED_LOCS[i+1];
// give them the same timestamp to make sure compareTo
// differentiates properly
loc0 = loc0 + " 2002-04-30T08:30Z";
loc1 = loc1 + " 2002-04-30T08:30Z";
AlternateLocation curLoc0 =
AlternateLocation.create(loc0);
AlternateLocation curLoc1 =
AlternateLocation.create(loc1);
int z = curLoc0.compareTo(curLoc1);
assertNotEquals("locations should compare to different values", 0, z);
}
}
/**
* Tests to make sure that alternate locations with equal URLs and
* different timestamps are considered different. This test relies
* on several properties of the VALID_TIMESTAMPS list. For example,
* the java Calendar class's set method does not take fractions of a
* second, so we consider timestamps with the same second reading as
* identical regardless of whether or not they have different fractions
* of that second, which is the behavior we want.
*/
public void testAlternateLocationCompareToWithEqualUrlsDifferentDates()
throws Exception {
// make sure that alternate locations with the same urls and different
// timestamps are considered same
for(int i=0;i<(HugeTestUtils.VALID_NONTIMESTAMPED_LOCS.length-1); i++) {
String nonTSloc0 = HugeTestUtils.VALID_NONTIMESTAMPED_LOCS[i];
String nonTSloc1 = HugeTestUtils.VALID_NONTIMESTAMPED_LOCS[i];
for(int j=0; j<VALID_TIMESTAMPS.length-1; j++) {
// give them the same timestamp to make sure compareTo
// differentiates properly
String loc0 = nonTSloc0 + " "+VALID_TIMESTAMPS[j];
String loc1 = nonTSloc1 + " "+VALID_TIMESTAMPS[j+1];
AlternateLocation curLoc0 = AlternateLocation.create(loc0);
AlternateLocation curLoc1 = AlternateLocation.create(loc1);
int z = curLoc0.compareTo(curLoc1);
assertEquals("locations should compare to same values:\r\n"+
curLoc0 + "\r\n" + curLoc1+"\r\n", 0, z);
}
}
}
/**
* Tests the construction of alternate locations with dates that do
* not meet the appropriate syntax to make sure they fail.
*/
public void testAlternateLocationConstructorWithInvalidDates() {
for(int i=0;i<(HugeTestUtils.VALID_NONTIMESTAMPED_LOCS.length-1);i++) {
String nonTSloc = HugeTestUtils.VALID_NONTIMESTAMPED_LOCS[i];
for(int j=0; j<INVALID_TIMESTAMPS.length-1; j++) {
String loc = nonTSloc + " "+INVALID_TIMESTAMPS[j];
try {
AlternateLocation al = AlternateLocation.create(loc);
} catch(IOException e) {
fail("could not create AlternateLocation with bad date");
}
}
}
}
/**
* Tests the construction of alternate locations with dates that do
* meet the appropriate syntax to make sure they fail.
*/
public void testAlternateLocationConstructorWithValidDates()
throws Exception {
// make sure that alternate locations with the same urls and different
// timestamps are considered different
for(int i=0;i<(HugeTestUtils.VALID_NONTIMESTAMPED_LOCS.length-1);i++) {
String nonTSloc = HugeTestUtils.VALID_NONTIMESTAMPED_LOCS[i];
for(int j=0; j<VALID_TIMESTAMPS.length-1; j++) {
String loc = nonTSloc + " "+VALID_TIMESTAMPS[j];
try {
AlternateLocation al = AlternateLocation.create(loc);
} catch (IOException e) {
fail("could not create AlternateLocation with valid date");
}
}
}
}
/**
* Test to make sure that we're handling firewalls fine -- rejecting
* firewalled locations and accepting non-firewalled locations.
*/
public void testAlternateLocationToMakeSureItDisallowsFirewalledHosts() throws Exception {
for(int i=0; i<HugeTestUtils.FIREWALLED_LOCS.length; i++) {
String loc = HugeTestUtils.FIREWALLED_LOCS[i];
try {
AlternateLocation al = AlternateLocation.create(loc);
fail("alt loc should not have accepted firewalled loc: "+loc);
} catch(Exception e) {
// this is expected
}
}
for(int i=0; i<HugeTestUtils.NON_FIREWALLED_LOCS.length; i++) {
String loc = HugeTestUtils.NON_FIREWALLED_LOCS[i];
AlternateLocation al = AlternateLocation.create(loc);
}
}
}