package com.limegroup.gnutella;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import junit.framework.Test;
import com.limegroup.gnutella.downloader.TestFile;
import com.limegroup.gnutella.downloader.TestUploader;
import com.limegroup.gnutella.messages.FeatureSearchData;
import com.limegroup.gnutella.messages.Message;
import com.limegroup.gnutella.messages.QueryReply;
import com.limegroup.gnutella.messages.QueryRequest;
import com.limegroup.gnutella.messages.vendor.CapabilitiesVM;
import com.limegroup.gnutella.messages.vendor.MessagesSupportedVendorMessage;
import com.limegroup.gnutella.settings.ConnectionSettings;
import com.limegroup.gnutella.settings.SearchSettings;
import com.limegroup.gnutella.settings.SharingSettings;
import com.limegroup.gnutella.stubs.ActivityCallbackStub;
import com.limegroup.gnutella.util.CommonUtils;
import com.limegroup.gnutella.util.PrivilegedAccessor;
/**
* Tests that What is new support is fully functional. We use a leaf here - we
* assume that an Ultrapeer will be equally functional.
*
*/
public class ServerSideWhatIsNewTest
extends ClientSideTestCase {
private static final int PORT=6669;
private static final int TIMEOUT=1000;
private static File berkeley = null;
private static File susheel = null;
private static File tempFile1 = null;
private static File tempFile2 = null;
private static File winInstaller = null;
private static File linInstaller = null;
private static File osxInstaller = null;
public ServerSideWhatIsNewTest(String name) {
super(name);
}
public static ActivityCallback getActivityCallback() {
return new ActivityCallbackStub();
}
public static Integer numUPs() {
return new Integer(1);
}
public static Test suite() {
return buildTestSuite(ServerSideWhatIsNewTest.class);
}
public static void main(String[] args) {
junit.textui.TestRunner.run(suite());
}
public void tearDown() {
// Now that this class is ClientSideTestCase derived, it reuses connections.
// Therefore, since we are re-sending the same query string repeatedly,
// we need to pause a bit longer between each test, or else DuplicateFilter.allow()
// will reject the subsequent queries as duplicates.
try {
Thread.sleep(3500);
} catch (InterruptedException unused) {}
}
private static void doSettings() throws Exception {
//Setup LimeWire backend. For testing other vendors, you can skip all
//this and manually configure a client in leaf mode to listen on port
//6669, with no slots and no connections. But you need to re-enable
//the interactive prompts below.
ConnectionSettings.PORT.setValue(PORT);
ConnectionSettings.DO_NOT_BOOTSTRAP.setValue(true);
ConnectionSettings.CONNECT_ON_STARTUP.setValue(false);
ConnectionSettings.LOCAL_IS_PRIVATE.setValue(false);
// Required so that the "swarmDownloadCatchesEarlyCreationTest" actually works =)
ConnectionSettings.CONNECTION_SPEED.setValue(SpeedConstants.T3_SPEED_INT);
SharingSettings.EXTENSIONS_TO_SHARE.setValue("txt;exe;bin;dmg");
setSharedDirectories( new File[] { _sharedDir, _savedDir } );
// get the resource file for com/limegroup/gnutella
berkeley =
CommonUtils.getResourceFile("com/limegroup/gnutella/berkeley.txt");
susheel =
CommonUtils.getResourceFile("com/limegroup/gnutella/susheel.txt");
// now move them to the share dir
CommonUtils.copy(berkeley, new File(_sharedDir, "berkeley.txt"));
CommonUtils.copy(susheel, new File(_sharedDir, "susheel.txt"));
berkeley = new File(_sharedDir, "berkeley.txt");
susheel = new File(_sharedDir, "susheel.txt");
winInstaller = new File(_sharedDir, "LimeWireWin3.69.0010.exe");
linInstaller = new File(_sharedDir, "LimeWireLinux.bin");
osxInstaller = new File(_sharedDir, "LimeWireOSX.dmg");
// make sure results get through
SearchSettings.MINIMUM_SEARCH_QUALITY.setValue(-2);
}
public void setUp() throws Exception {
doSettings();
}
public static boolean shouldRespondToPing() {
return false;
}
///////////////////////// Actual Tests ////////////////////////////
// THIS TEST SHOULD BE RUN FIRST!!
// just test that What Is New support is advertised
public void testSendsCapabilitiesMessage() throws Exception {
//testUP = connect(rs, 6355, true);
Connection testUP = super.testUP[0];
// send a MessagesSupportedMessage and capabilities VM
testUP.send(MessagesSupportedVendorMessage.instance());
testUP.send(CapabilitiesVM.instance());
testUP.flush();
Thread.sleep(100);
// we expect to get a CVM back
Message m = null;
do {
m = testUP.receive(TIMEOUT);
} while (!(m instanceof CapabilitiesVM)) ;
assertTrue(((CapabilitiesVM)m).supportsWhatIsNew());
// client side seems to follow the setup process A-OK
}
// test that the CreationTimeCache is as expected
public void testCreationTimeCacheInitialState() throws Exception {
// wait for fm to finish
int i = 0;
for (; (i < 15) && (rs.getNumSharedFiles() < 2); i++)
Thread.sleep(1000);
if (i == 15) assertTrue(false);
// we should be sharing two files - two text files.
assertEquals(2, rs.getNumSharedFiles());
CreationTimeCache ctCache = CreationTimeCache.instance();
FileManager fm = rs.getFileManager();
URN berkeleyURN = fm.getURNForFile(berkeley);
URN susheelURN = fm.getURNForFile(susheel);
{
Map urnToLong =
(Map)PrivilegedAccessor.getValue(ctCache, "URN_TO_TIME_MAP");
assertEquals(2, urnToLong.size());
assertNotNull(""+urnToLong, urnToLong.get(berkeleyURN));
assertNotNull(""+urnToLong, urnToLong.get(susheelURN));
}
{
Map longToUrns =
(Map)PrivilegedAccessor.getValue(ctCache, "TIME_TO_URNSET_MAP");
if (longToUrns.size() == 1) {
Iterator iter = longToUrns.entrySet().iterator();
Set urnSet = (Set)((Map.Entry)iter.next()).getValue();
assertTrue(urnSet.contains(berkeleyURN));
assertTrue(urnSet.contains(susheelURN));
assertEquals(2, urnSet.size());
}
else if (longToUrns.size() == 2) {
Iterator iter = longToUrns.entrySet().iterator();
Set urnSet = (Set)((Map.Entry)iter.next()).getValue();
assertTrue(
( urnSet.contains(berkeleyURN) &&
!urnSet.contains(susheelURN) )
||
( !urnSet.contains(berkeleyURN) &&
urnSet.contains(susheelURN) )
);
assertEquals(1, urnSet.size());
urnSet = (Set)((Map.Entry)iter.next()).getValue();
assertTrue(
( urnSet.contains(berkeleyURN) &&
!urnSet.contains(susheelURN) )
||
( !urnSet.contains(berkeleyURN) &&
urnSet.contains(susheelURN) )
);
assertEquals(1, urnSet.size());
}
else assertTrue("Bad Cache!", false);
}
}
// make sure that a what is new query is answered correctly
public void testWhatIsNewQueryBasic() throws Exception {
Connection testUP = super.testUP[0];
drain(testUP);
QueryRequest whatIsNewQuery =
new QueryRequest(GUID.makeGuid(), (byte)2,
QueryRequest.WHAT_IS_NEW_QUERY_STRING, "", null,
null, null, false, Message.N_UNKNOWN, false,
FeatureSearchData.WHAT_IS_NEW);
whatIsNewQuery.hop();
testUP.send(whatIsNewQuery);
testUP.flush();
// give time to process
Thread.sleep(1000);
QueryReply reply =
(QueryReply) getFirstInstanceOfMessageType(testUP,
QueryReply.class);
assertNotNull(reply);
assertEquals(2, reply.getResultCount());
Iterator iter = reply.getResults();
Response currResp = (Response) iter.next();
assertTrue(currResp.getName().equals("berkeley.txt") ||
currResp.getName().equals("susheel.txt"));
currResp = (Response) iter.next();
assertTrue(currResp.getName().equals("berkeley.txt") ||
currResp.getName().equals("susheel.txt"));
assertFalse(iter.hasNext());
}
// make sure that a what is new query meta query is answered correctly
public void testWhatIsNewQueryMeta() throws Exception {
Connection testUP = super.testUP[0];
drain(testUP);
{
QueryRequest whatIsNewQuery =
new QueryRequest(GUID.makeGuid(), (byte)2,
QueryRequest.WHAT_IS_NEW_QUERY_STRING, "", null,
null, null, false, Message.N_UNKNOWN, false,
FeatureSearchData.WHAT_IS_NEW, false,
0 | QueryRequest.AUDIO_MASK);
whatIsNewQuery.hop();
testUP.send(whatIsNewQuery);
testUP.flush();
// give time to process
Thread.sleep(2000);
QueryReply reply =
(QueryReply) getFirstInstanceOfMessageType(testUP,
QueryReply.class);
assertNull(reply);
}
{
QueryRequest whatIsNewQuery =
new QueryRequest(GUID.makeGuid(), (byte)2,
QueryRequest.WHAT_IS_NEW_QUERY_STRING, "", null,
null, null, false, Message.N_UNKNOWN, false,
FeatureSearchData.WHAT_IS_NEW, false,
0 | QueryRequest.DOC_MASK);
whatIsNewQuery.hop();
testUP.send(whatIsNewQuery);
testUP.flush();
// give time to process
Thread.sleep(1000);
QueryReply reply =
(QueryReply) getFirstInstanceOfMessageType(testUP,
QueryReply.class);
assertNotNull(reply);
assertEquals(2, reply.getResultCount());
Iterator iter = reply.getResults();
Response currResp = (Response) iter.next();
assertTrue(currResp.getName().equals("berkeley.txt") ||
currResp.getName().equals("susheel.txt"));
currResp = (Response) iter.next();
assertTrue(currResp.getName().equals("berkeley.txt") ||
currResp.getName().equals("susheel.txt"));
assertFalse(iter.hasNext());
}
}
// test that the creation time cache handles the additional sharing of files
// fine
public void testAddSharedFiles() throws Exception {
CreationTimeCache ctCache = CreationTimeCache.instance();
FileManager fm = rs.getFileManager();
URN berkeleyURN = fm.getURNForFile(berkeley);
URN susheelURN = fm.getURNForFile(susheel);
tempFile1 = new File("tempFile1.txt");
tempFile2 = new File("tempFile2.txt");
tempFile1.deleteOnExit(); tempFile2.deleteOnExit();
FileWriter writer = null;
{
writer = new FileWriter(tempFile1);
writer.write(tempFile1.getName(), 0, tempFile1.getName().length());
writer.flush();
writer.close();
}
{
writer = new FileWriter(tempFile2);
writer.write(tempFile2.getName(), 0, tempFile2.getName().length());
writer.flush();
writer.close();
}
// now move them to the share dir
CommonUtils.copy(tempFile1, new File(_sharedDir, "tempFile1.txt"));
CommonUtils.copy(tempFile2, new File(_sharedDir, "tempFile2.txt"));
tempFile1 = new File(_sharedDir, "tempFile1.txt");
tempFile2 = new File(_sharedDir, "tempFile2.txt");
assertTrue(tempFile1.exists());
assertTrue(tempFile2.exists());
rs.getFileManager().loadSettings();
int i = 0;
for (; (i < 15) && (rs.getNumSharedFiles() < 4); i++)
Thread.sleep(1000);
if (i == 15)
fail("num shared files? " + rs.getNumSharedFiles());
URN tempFile1URN = fm.getURNForFile(tempFile1);
URN tempFile2URN = fm.getURNForFile(tempFile2);
{
Map urnToLong =
(Map)PrivilegedAccessor.getValue(ctCache, "URN_TO_TIME_MAP");
assertEquals(4, urnToLong.size());
assertNotNull(""+urnToLong, urnToLong.get(berkeleyURN));
assertNotNull(""+urnToLong, urnToLong.get(susheelURN));
assertNotNull(""+urnToLong, urnToLong.get(tempFile1URN));
assertNotNull(""+urnToLong, urnToLong.get(tempFile2URN));
}
{
Map longToUrns =
(Map)PrivilegedAccessor.getValue(ctCache, "TIME_TO_URNSET_MAP");
assertTrue(""+longToUrns,
(longToUrns.size() == 2) || (longToUrns.size() == 3) ||
(longToUrns.size() == 4));
}
}
// test that after the sharing of additional files, the what is new query
// results in something else
public void testWhatIsNewQueryNewFiles() throws Exception {
Connection testUP = super.testUP[0];
drain(testUP);
QueryRequest whatIsNewQuery =
new QueryRequest(GUID.makeGuid(), (byte)2,
QueryRequest.WHAT_IS_NEW_QUERY_STRING, "", null,
null, null, false, Message.N_UNKNOWN, false,
FeatureSearchData.WHAT_IS_NEW);
testUP.send(whatIsNewQuery);
testUP.flush();
// give time to process
Thread.sleep(1000);
QueryReply reply =
(QueryReply) getFirstInstanceOfMessageType(testUP,
QueryReply.class);
assertNotNull(reply);
assertEquals(3, reply.getResultCount());
boolean gotTempFile1 = false, gotTempFile2 = false;
Iterator iter = reply.getResults();
while (iter.hasNext()) {
Response currResp = (Response) iter.next();
if (currResp.getName().equals(tempFile1.getName()))
gotTempFile1 = true;
if (currResp.getName().equals(tempFile2.getName()))
gotTempFile2 = true;
}
assertTrue("file 1? " + gotTempFile1 + ", file 2? " +
gotTempFile2, gotTempFile1 && gotTempFile2);
}
// test that the fileChanged method of FM does the right thing. this isn't
// a total black box test, but hacking up the changing of ID3 data isn't
// worth the cost. this test should be good enough....
public void testFileChanged() throws Exception {
FileManager fm = rs.getFileManager();
CreationTimeCache ctCache = CreationTimeCache.instance();
URN tempFile1URN = fm.getURNForFile(tempFile1);
Long cTime = ctCache.getCreationTime(tempFile1URN);
FileWriter writer = null;
{
writer = new FileWriter(tempFile1);
writer.write(berkeley.getName(), 0, berkeley.getName().length());
writer.flush();
writer.close();
}
FileDesc beforeChanged = fm.getFileDescForFile(tempFile1);
assertNotNull(beforeChanged);
fm.fileChanged(tempFile1);
Thread.sleep(3000);
FileDesc afterChanged = fm.getFileDescForFile(tempFile1);
assertNotNull(afterChanged);
assertNotSame(beforeChanged, afterChanged);
assertNotNull(fm.getURNForFile(tempFile1));
assertNotEquals(tempFile1URN, fm.getURNForFile(tempFile1));
assertEquals(ctCache.getCreationTime(fm.getURNForFile(tempFile1)),
cTime);
// now just send another What Is New query and make sure everything
// is kosher - probably overkill but whatever....
Connection testUP = super.testUP[0];
drain(testUP);
QueryRequest whatIsNewQuery =
new QueryRequest(GUID.makeGuid(), (byte)2,
QueryRequest.WHAT_IS_NEW_QUERY_STRING, "", null,
null, null, false, Message.N_UNKNOWN, false,
FeatureSearchData.WHAT_IS_NEW);
testUP.send(whatIsNewQuery);
testUP.flush();
// give time to process
Thread.sleep(1000);
QueryReply reply =
(QueryReply) getFirstInstanceOfMessageType(testUP,
QueryReply.class);
assertNotNull(reply);
assertEquals(3, reply.getResultCount());
boolean gotTempFile1 = false, gotTempFile2 = false;
Iterator iter = reply.getResults();
while (iter.hasNext()) {
Response currResp = (Response) iter.next();
if (currResp.getName().equals(tempFile1.getName()))
gotTempFile1 = true;
if (currResp.getName().equals(tempFile2.getName()))
gotTempFile2 = true;
}
assertTrue("file 1? " + gotTempFile1 + ", file 2? " +
gotTempFile2, gotTempFile1 && gotTempFile2);
}
// test that the fileChanged method of FM does the right thing when you
// change the file to a existing URN.
public void testFileChangedToExistingURN() throws Exception {
FileManager fm = rs.getFileManager();
CreationTimeCache ctCache = CreationTimeCache.instance();
URN tempFile1URN = fm.getURNForFile(tempFile1);
// URN tempFile2URN = fm.getURNForFile(tempFile2);
// we are changing tempFile1 to become tempFile2 - but since we
// call fileChanged(), then the common URN should get tempFile1's
// cTime
Long cTime = ctCache.getCreationTime(tempFile1URN);
FileWriter writer = null;
{
writer = new FileWriter(tempFile1);
writer.write(tempFile2.getName(), 0, tempFile2.getName().length());
writer.flush();
writer.close();
}
FileDesc beforeChanged = fm.getFileDescForFile(tempFile1);
assertNotNull(beforeChanged);
fm.fileChanged(tempFile1);
Thread.sleep(3000);
FileDesc afterChanged = fm.getFileDescForFile(tempFile1);
assertNotNull(afterChanged);
assertNotSame(beforeChanged, afterChanged);
assertNotNull(fm.getURNForFile(tempFile1));
assertNotEquals(tempFile1URN, fm.getURNForFile(tempFile1));
assertEquals(fm.getURNForFile(tempFile1), fm.getURNForFile(tempFile2));
assertEquals(ctCache.getCreationTime(fm.getURNForFile(tempFile1)),
cTime);
// now just send another What Is New query and make sure everything
// is kosher - probbably overkill but whatever....
Connection testUP = super.testUP[0];
drain(testUP);
QueryRequest whatIsNewQuery =
new QueryRequest(GUID.makeGuid(), (byte)2,
QueryRequest.WHAT_IS_NEW_QUERY_STRING, "", null,
null, null, false, Message.N_UNKNOWN, false,
FeatureSearchData.WHAT_IS_NEW);
testUP.send(whatIsNewQuery);
testUP.flush();
// give time to process
Thread.sleep(1000);
QueryReply reply =
(QueryReply) getFirstInstanceOfMessageType(testUP,
QueryReply.class);
assertNotNull(reply);
assertEquals(3, reply.getResultCount());
boolean gotTempFile1 = false, gotTempFile2 = false;
Iterator iter = reply.getResults();
while (iter.hasNext()) {
Response currResp = (Response) iter.next();
if (currResp.getName().equals(tempFile1.getName()))
gotTempFile1 = true;
if (currResp.getName().equals(tempFile2.getName()))
gotTempFile2 = true;
}
assertTrue("file 1? " + gotTempFile1 + ", file 2? " +
gotTempFile2, !gotTempFile1 && gotTempFile2);
}
// test that the FileManager.removeFileIfShared method works
public void testRemoveSharedFile() throws Exception {
FileManager fm = rs.getFileManager();
CreationTimeCache ctCache = CreationTimeCache.instance();
int size = 0;
{
Map urnToLong =
(Map)PrivilegedAccessor.getValue(ctCache, "URN_TO_TIME_MAP");
assertEquals(3, urnToLong.size());
}
{
Map longToUrns =
(Map)PrivilegedAccessor.getValue(ctCache, "TIME_TO_URNSET_MAP");
size = longToUrns.size();
assertTrue((longToUrns.size() == 2) || (longToUrns.size() == 3));
}
// tempFile1 is the same URN as tempFile2
fm.removeFileIfShared(tempFile1);
{
Map urnToLong =
(Map)PrivilegedAccessor.getValue(ctCache, "URN_TO_TIME_MAP");
assertEquals(3, urnToLong.size());
}
{
Map longToUrns =
(Map)PrivilegedAccessor.getValue(ctCache, "TIME_TO_URNSET_MAP");
assertEquals(longToUrns.size(), size);
}
// tempFile2 should result in a delete
fm.removeFileIfShared(tempFile2);
{
Map urnToLong =
(Map)PrivilegedAccessor.getValue(ctCache, "URN_TO_TIME_MAP");
assertEquals(2, urnToLong.size());
}
{
Map longToUrns =
(Map)PrivilegedAccessor.getValue(ctCache, "TIME_TO_URNSET_MAP");
assertEquals(longToUrns.size(), (size-1));
}
}
// manually delete a file, make sure it isn't shared and that the CTC has
// the correct sizes, etc...
public void testManualFileDeleteLoadSettings() throws Exception {
FileManager fm = rs.getFileManager();
CreationTimeCache ctCache = CreationTimeCache.instance();
tempFile1.delete(); tempFile1 = null;
tempFile2.delete(); tempFile2 = null;
berkeley.delete(); berkeley = null;
fm.loadSettings();
Thread.sleep(2000);
assertEquals("num shared files", 1, rs.getNumSharedFiles());
URN susheelURN = fm.getURNForFile(susheel);
{
Map urnToLong =
(Map)PrivilegedAccessor.getValue(ctCache, "URN_TO_TIME_MAP");
assertEquals(""+urnToLong, 1, urnToLong.size());
assertNotNull(""+urnToLong, urnToLong.get(susheelURN));
}
{
Map longToUrns =
(Map)PrivilegedAccessor.getValue(ctCache, "TIME_TO_URNSET_MAP");
assertEquals(""+longToUrns, 1, longToUrns.size());
}
}
// download a file and make sure the creation time given back is stored...
public void testDownloadCapturesCreationTime() throws Exception {
FileManager fm = rs.getFileManager();
CreationTimeCache ctCache = CreationTimeCache.instance();
final int UPLOADER_PORT = 10000;
byte[] guid = GUID.makeGuid();
TestUploader uploader = new TestUploader("whatever.txt", UPLOADER_PORT);
Long cTime = new Long(2);
uploader.setCreationTime(cTime);
Set urns = new HashSet();
urns.add(TestFile.hash());
RemoteFileDesc rfd = new RemoteFileDesc("127.0.0.1", UPLOADER_PORT, 1,
"whatever.txt",
TestFile.length(),
guid, 1, false, 3,
false, null, urns, false,
false, "LIME", 0, new HashSet(), -1);
Downloader downloader =
rs.download(new RemoteFileDesc[] { rfd }, false, new GUID(guid));
int sleeps = 0;
while (downloader.getState() != Downloader.COMPLETE) {
Thread.sleep(1000);
sleeps++;
if (sleeps > 320) assertTrue("download never completed", false);
}
assertEquals("num shared files? " + rs.getNumSharedFiles(), 2,
rs.getNumSharedFiles());
File newFile = new File(_savedDir, "whatever.txt");
assertTrue(newFile.exists());
URN newFileURN = fm.getURNForFile(newFile);
assertEquals(TestFile.hash(), newFileURN);
assertEquals(cTime, ctCache.getCreationTime(newFileURN));
{
Map urnToLong =
(Map)PrivilegedAccessor.getValue(ctCache, "URN_TO_TIME_MAP");
assertEquals(""+urnToLong, 2, urnToLong.size());
}
{
Map longToUrns =
(Map)PrivilegedAccessor.getValue(ctCache, "TIME_TO_URNSET_MAP");
assertEquals(""+longToUrns, 2, longToUrns.size());
}
}
// download a file and make sure the creation time given back is stored...
public void testSwarmDownloadCapturesOlderCreationTime() throws Exception {
FileManager fm = rs.getFileManager();
CreationTimeCache ctCache = CreationTimeCache.instance();
// get rid of the old shared file
File newFile = new File(_savedDir, "whatever.txt");
fm.removeFileIfShared(newFile);
newFile.delete();
assertEquals("num shared files? " + rs.getNumSharedFiles(), 1,
rs.getNumSharedFiles());
final int UPLOADER_PORT = 20000;
byte[] guid = GUID.makeGuid();
TestUploader uploader[] = new TestUploader[4];
Long cTime[] = new Long[uploader.length];
RemoteFileDesc rfds[] = new RemoteFileDesc[uploader.length];
for (int i = 0; i < uploader.length; i++) {
uploader[i] = new TestUploader("anita.txt", UPLOADER_PORT+i);
uploader[i].setRate(50);
cTime[i] = new Long(5+i);
uploader[i].setCreationTime(cTime[i]);
Set urns = new HashSet();
urns.add(TestFile.hash());
rfds[i] = new RemoteFileDesc("127.0.0.1", UPLOADER_PORT+i, 1,
"anita.txt", TestFile.length(),
guid, 1, false, 3,
false, null, urns, false,
false, "LIME", 0, new HashSet(), -1);
}
Downloader downloader = rs.download(rfds, false, new GUID(guid));
Thread.sleep(2000);
assertTrue(downloader.getState() != Downloader.COMPLETE);
// make sure that the partial file has a creation time - by now one of
// the downloaders must have got X-Create-Time
assertNotNull(ctCache.getCreationTime(TestFile.hash()));
int sleeps = 0;
while (downloader.getState() != Downloader.COMPLETE) {
Thread.sleep(1000);
sleeps++;
if (sleeps > 120) assertTrue("download never completed", false);
}
assertEquals("num shared files? " + rs.getNumSharedFiles(), 2,
rs.getNumSharedFiles());
{
Map urnToLong =
(Map)PrivilegedAccessor.getValue(ctCache, "URN_TO_TIME_MAP");
assertEquals(""+urnToLong, 2, urnToLong.size());
}
{
Map longToUrns =
(Map)PrivilegedAccessor.getValue(ctCache, "TIME_TO_URNSET_MAP");
assertEquals(""+longToUrns, 2, longToUrns.size());
}
newFile = new File(_savedDir, "anita.txt");
assertTrue(newFile.exists());
URN newFileURN = fm.getURNForFile(newFile);
assertEquals(cTime[0], ctCache.getCreationTime(newFileURN));
}
public void testInstallersNotSharedInCache() throws Exception {
// Make sure that the modified times are not the same
susheel.setLastModified(123456);
berkeley.setLastModified(123457);
FileManager fm = rs.getFileManager();
CreationTimeCache ctCache = CreationTimeCache.instance();
winInstaller =
CommonUtils.getResourceFile("com/limegroup/gnutella/Backend.java");
linInstaller =
CommonUtils.getResourceFile("com/limegroup/gnutella/GUIDTest.java");
osxInstaller =
CommonUtils.getResourceFile("com/limegroup/gnutella/UrnTest.java");
// Gotta make use of the force-share folder for this test
if( FileManager.PROGRAM_SHARE.exists() ) {
File [] toDelete = FileManager.PROGRAM_SHARE.listFiles();
for (int j = 0; j < toDelete.length; j++) {
toDelete[j].delete();
}
} else {
FileManager.PROGRAM_SHARE.mkdir();
}
CommonUtils.copy(winInstaller,
new File(FileManager.PROGRAM_SHARE, "LimeWireWin3.69.0010.exe"));
CommonUtils.copy(linInstaller,
new File(FileManager.PROGRAM_SHARE, "LimeWireLinux.bin"));
CommonUtils.copy(osxInstaller,
new File(FileManager.PROGRAM_SHARE, "LimeWireOSX.dmg"));
rs.getFileManager().loadSettings();
int i = 0;
for (; (i < 15) && (rs.getNumSharedFiles()+rs.getFileManager().getNumForcedFiles() < 5); i++)
Thread.sleep(1000);
if (i == 15)
fail("num shared files? " + rs.getNumSharedFiles());
// we should be sharing two files - two text files and three installers
// but the creation time cache should only have the two text files
// as entries....
//
// NOTE: with forced folder sharing, there will be only 2 shared files (forced
// files don't count), and 3 forced shared files
assertEquals(2, rs.getNumSharedFiles());
assertEquals(3, rs.getFileManager().getNumForcedFiles());
{
Map urnToLong =
(Map)PrivilegedAccessor.getValue(ctCache, "URN_TO_TIME_MAP");
assertEquals(""+urnToLong, 2, urnToLong.size());
}
{
Map longToUrns =
(Map)PrivilegedAccessor.getValue(ctCache, "TIME_TO_URNSET_MAP");
assertEquals(""+longToUrns, 2, longToUrns.size());
}
// make sure the installer urns are not in the cache
{
assertTrue(winInstaller.exists());
URN installerURN = fm.getURNForFile(winInstaller);
assertNull(ctCache.getCreationTime(installerURN));
}
{
assertTrue(winInstaller.exists());
URN installerURN = fm.getURNForFile(linInstaller);
assertNull(ctCache.getCreationTime(installerURN));
}
{
assertTrue(winInstaller.exists());
URN installerURN = fm.getURNForFile(osxInstaller);
assertNull(ctCache.getCreationTime(installerURN));
}
// make sure berkeley and susheel are in the cache.
{
assertTrue(berkeley.exists());
assertNotNull(ctCache.getCreationTime(fm.getURNForFile(berkeley)));
}
{
assertTrue(susheel.exists());
assertNotNull(ctCache.getCreationTime(fm.getURNForFile(susheel)));
}
File [] toDelete = FileManager.PROGRAM_SHARE.listFiles();
for (int j = 0; j < toDelete.length; j++) {
toDelete[j].delete();
}
FileManager.PROGRAM_SHARE.delete();
}
}