/*
* Jitsi, the OpenSource Java VoIP and Instant Messaging client.
*
* Copyright @ 2015 Atlassian Pty Ltd
*
* Licensed 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.
*/
package net.java.sip.communicator.slick.protocol.generic;
import java.io.*;
import java.util.*;
import junit.framework.*;
import net.java.sip.communicator.service.protocol.*;
import net.java.sip.communicator.service.protocol.event.*;
import net.java.sip.communicator.util.*;
import org.jitsi.service.fileaccess.*;
import org.osgi.framework.*;
/**
* Generic test for file transfer operationset.
*
* @author Damian Minkov
*/
public abstract class TestOperationSetFileTransfer
extends TestCase
{
private static final Logger logger
= Logger.getLogger(TestOperationSetFileTransfer.class);
private FileAccessService fileAccessService = null;
public TestOperationSetFileTransfer(String name)
{
super(name);
}
public TestOperationSetFileTransfer()
{
}
@Override
protected void setUp()
throws Exception
{
super.setUp();
start();
}
@Override
protected void tearDown() throws Exception
{
stop();
super.tearDown();
}
private FileAccessService getFileService()
{
if(fileAccessService == null)
{
ServiceReference ref = getContext()
.getServiceReference(FileAccessService.class.getName());
fileAccessService = (FileAccessService)getContext().getService(ref);
}
return fileAccessService;
}
private File getTempFileToTransfer(int size)
throws Exception
{
File fileToTransfer =
getFileService().getTemporaryFile();
byte[] buff = new byte[size];
Arrays.fill(buff, (byte)1);
FileOutputStream out = new FileOutputStream(fileToTransfer);
out.write(buff);
out.flush();
out.close();
return fileToTransfer;
}
/**
* Full file transfer process. Receiver and sender must end with event
* fired for successful finish of the transfers on both sides.
* @throws Exception
*/
public void testSendAndReceive()
throws Exception
{
if(!enableTestSendAndReceive())
return;
logger.trace("Start test : send and receive ok.");
File fileToTransfer = getTempFileToTransfer(123456);
OperationSetFileTransfer ftOpSet1 = getOpSetFilTransfer1();
OperationSetFileTransfer ftOpSet2 = getOpSetFilTransfer2();
FileTransferStatusEventCollector senderStatusListener =
new FileTransferStatusEventCollector("Sender");
FileTransferEventCollector senderFTListerner =
new FileTransferEventCollector("Sender", senderStatusListener);
ftOpSet1.addFileTransferListener(senderFTListerner);
FileTransferStatusEventCollector receiverStatusListener =
new FileTransferStatusEventCollector("Receiver");
FileTransferEventCollector receiverFTListerner =
new FileTransferEventCollector("Receiver", receiverStatusListener);
ftOpSet2.addFileTransferListener(receiverFTListerner);
try
{
ftOpSet1.sendFile(getContact1(), fileToTransfer);
senderFTListerner.waitForEvent(2000);
receiverFTListerner.waitForEvent(8000);
senderStatusListener.waitForEvent(2000);
// sender
assertEquals("A file transfer created must be received on send side"
, 1, senderFTListerner.collectedEvents.size());
FileTransferCreatedEvent fileTransferCreatedEvent
= (FileTransferCreatedEvent)
senderFTListerner.collectedEvents.get(0);
assertEquals("FileTransfer file"
,fileTransferCreatedEvent.
getFileTransfer().getLocalFile()
,fileToTransfer);
assertEquals("A file transfer status changed - " +
"preparing received on send side"
, 1, senderStatusListener.collectedEvents.size());
FileTransferStatusChangeEvent fileTransferStatusEvent
= senderStatusListener.collectedEvents.get(0);
assertEquals("Event must be preparing"
,FileTransferStatusChangeEvent.PREPARING
,fileTransferStatusEvent.getNewStatus());
// receiver
assertEquals("A file transfer request must be " +
"received on the receiver side"
, 1, receiverFTListerner.collectedEvents.size());
FileTransferRequestEvent fileTransferRequestEvent
= (FileTransferRequestEvent)
receiverFTListerner.collectedEvents.get(0);
IncomingFileTransferRequest req =
fileTransferRequestEvent.getRequest();
assertEquals("FileTransfer file name must be the same"
,req.getFileName()
,fileToTransfer.getName());
assertEquals("FileTransfer file size must be the same"
,req.getFileSize()
,fileToTransfer.length());
// now we will accpet the file
// but let first clear the event listeners
senderFTListerner.clear();
receiverFTListerner.clear();
senderStatusListener.clear();
File receiveFile = getFileService().getTemporaryFile();
req.acceptFile(receiveFile);
senderFTListerner.waitForEvent(4000);
receiverFTListerner.waitForEvent(4000);
//receiver
assertEquals("A file transfer created must be " +
"received on receiver side"
, 1, receiverFTListerner.collectedEvents.size());
fileTransferCreatedEvent = (FileTransferCreatedEvent)
receiverFTListerner.collectedEvents.get(0);
assertEquals("FileTransfer file"
,fileTransferCreatedEvent.
getFileTransfer().getLocalFile()
,receiveFile);
receiverStatusListener.waitForEvent(30000, 3);
// Some times we can receive only two events,
// when connection is quickly established the preparing event
// is missing.
assertTrue("A file transfer status changed - " +
"preparing, inprogress and completed received on receiver side"
, 3 == receiverStatusListener.collectedEvents.size()
||
2 == receiverStatusListener.collectedEvents.size());
fileTransferStatusEvent
= receiverStatusListener.collectedEvents.get(0);
if(receiverStatusListener.collectedEvents.size() == 3)
{
assertEquals("Event must be preparing"
,FileTransferStatusChangeEvent.PREPARING
,fileTransferStatusEvent.getNewStatus());
fileTransferStatusEvent
= receiverStatusListener.collectedEvents.get(1);
}
assertEquals("Event must be in_progress"
,FileTransferStatusChangeEvent.IN_PROGRESS
,fileTransferStatusEvent.getNewStatus());
if(receiverStatusListener.collectedEvents.size() == 3)
fileTransferStatusEvent
= receiverStatusListener.collectedEvents.get(2);
else
fileTransferStatusEvent
= receiverStatusListener.collectedEvents.get(1);
assertEquals("Event must be completed"
,FileTransferStatusChangeEvent.COMPLETED
,fileTransferStatusEvent.getNewStatus());
// sender
senderStatusListener.waitForEvent(4000, 2);
assertTrue("Completed event must be received",
senderStatusListener.contains(
FileTransferStatusChangeEvent.COMPLETED));
}
finally
{
ftOpSet1.removeFileTransferListener(senderFTListerner);
ftOpSet2.addFileTransferListener(receiverFTListerner);
}
}
/**
* Sender sends file transfer request and cancel it before the remote side
* accept it. (This is not supported by all protocols)
*
* @throws Exception
*/
public void testSenderCancelBeforeAccepted()
throws Exception
{
if(!enableTestSenderCancelBeforeAccepted())
return;
logger.trace("Start test : sender will cancel transfer before "
+ "receiver accept or decline it");
File fileToTransfer = getTempFileToTransfer(1234567);
OperationSetFileTransfer ftOpSet1 = getOpSetFilTransfer1();
OperationSetFileTransfer ftOpSet2 = getOpSetFilTransfer2();
FileTransferStatusEventCollector senderStatusListener =
new FileTransferStatusEventCollector("Sender");
FileTransferEventCollector senderFTListerner =
new FileTransferEventCollector("Sender", senderStatusListener);
ftOpSet1.addFileTransferListener(senderFTListerner);
FileTransferEventCollector receiverFTListerner =
new FileTransferEventCollector("Receiver", null);
ftOpSet2.addFileTransferListener(receiverFTListerner);
try
{
FileTransfer ft1 = ftOpSet1.sendFile(getContact1(), fileToTransfer);
senderFTListerner.waitForEvent(2000);
receiverFTListerner.waitForEvent(2000);
senderStatusListener.waitForEvent(2000);
// sender
assertEquals("A file transfer created must be received on send side"
, 1, senderFTListerner.collectedEvents.size());
FileTransferCreatedEvent fileTransferCreatedEvent
= (FileTransferCreatedEvent)
senderFTListerner.collectedEvents.get(0);
assertEquals("FileTransfer file"
,fileTransferCreatedEvent.
getFileTransfer().getLocalFile()
,fileToTransfer);
assertEquals("A file transfer status changed - " +
"preparing received on send side"
, 1, senderStatusListener.collectedEvents.size());
FileTransferStatusChangeEvent fileTransferStatusEvent
= senderStatusListener.collectedEvents.get(0);
assertEquals("Event must be preparing"
,FileTransferStatusChangeEvent.PREPARING
,fileTransferStatusEvent.getNewStatus());
// receiver
assertEquals("A file transfer request must be received " +
"on the receiver side"
, 1, receiverFTListerner.collectedEvents.size());
FileTransferRequestEvent fileTransferRequestEvent
= (FileTransferRequestEvent)
receiverFTListerner.collectedEvents.get(0);
IncomingFileTransferRequest req =
fileTransferRequestEvent.getRequest();
assertEquals("FileTransfer file name must be the same"
,req.getFileName()
,fileToTransfer.getName());
assertEquals("FileTransfer file size must be the same"
,req.getFileSize()
,fileToTransfer.length());
// now we will cancel the file
// but let first clear the event listeners
senderFTListerner.clear();
receiverFTListerner.clear();
senderStatusListener.clear();
// now cancel
ft1.cancel();
receiverFTListerner.waitForEvent(6000);
senderStatusListener.waitForEvent(6000);
// sender
assertEquals("A file transfer status changed - " +
"cancel received on send side"
, 1, senderStatusListener.collectedEvents.size());
fileTransferStatusEvent
= senderStatusListener.collectedEvents.get(0);
assertEquals("Event must be canceled"
,FileTransferStatusChangeEvent.CANCELED
,fileTransferStatusEvent.getNewStatus());
// the receiver must receive event refused
assertEquals("A file transfer cancel must be " +
"received on receiver side"
, 1, receiverFTListerner.collectedEvents.size());
fileTransferRequestEvent = (FileTransferRequestEvent)
receiverFTListerner.collectedEvents.get(0);
assertTrue("FileTransfer must be canceled"
,receiverFTListerner.isCanceled());
}
finally
{
ftOpSet1.removeFileTransferListener(senderFTListerner);
ftOpSet2.addFileTransferListener(receiverFTListerner);
}
}
public void testReceiverDecline()
throws Exception
{
if(!enableTestReceiverDecline())
return;
logger.info("Start test: receiver will decline incoming fileTransfer");
File fileToTransfer = getTempFileToTransfer(12345);
OperationSetFileTransfer ftOpSet1 = getOpSetFilTransfer1();
OperationSetFileTransfer ftOpSet2 = getOpSetFilTransfer2();
FileTransferStatusEventCollector senderStatusListener =
new FileTransferStatusEventCollector("Sender");
FileTransferEventCollector senderFTListerner =
new FileTransferEventCollector("Sender", senderStatusListener);
ftOpSet1.addFileTransferListener(senderFTListerner);
FileTransferEventCollector receiverFTListerner =
new FileTransferEventCollector("Receiver", null);
ftOpSet2.addFileTransferListener(receiverFTListerner);
try
{
ftOpSet1.sendFile(getContact1(), fileToTransfer);
senderFTListerner.waitForEvent(2000);
receiverFTListerner.waitForEvent(6000);
senderStatusListener.waitForEvent(2000);
// sender
assertEquals("A file transfer created must be received on send side"
, 1, senderFTListerner.collectedEvents.size());
FileTransferCreatedEvent fileTransferCreatedEvent
= (FileTransferCreatedEvent)
senderFTListerner.collectedEvents.get(0);
assertEquals("FileTransfer file"
,fileTransferCreatedEvent.
getFileTransfer().getLocalFile()
,fileToTransfer);
assertEquals("A file transfer status changed - " +
"preparing received on send side"
, 1, senderStatusListener.collectedEvents.size());
FileTransferStatusChangeEvent fileTransferStatusEvent
= senderStatusListener.collectedEvents.get(0);
assertEquals("Event must be preparing"
,FileTransferStatusChangeEvent.PREPARING
,fileTransferStatusEvent.getNewStatus());
// receiver
assertEquals("A file transfer request must be " +
"received on the receiver side"
, 1, receiverFTListerner.collectedEvents.size());
FileTransferRequestEvent fileTransferRequestEvent
= (FileTransferRequestEvent)
receiverFTListerner.collectedEvents.get(0);
IncomingFileTransferRequest req =
fileTransferRequestEvent.getRequest();
assertEquals("FileTransfer file name must be the same"
,req.getFileName()
,fileToTransfer.getName());
assertEquals("FileTransfer file size must be the same"
,req.getFileSize()
,fileToTransfer.length());
// now we will decline the file
// but let first clear the event listeners
senderFTListerner.clear();
receiverFTListerner.clear();
senderStatusListener.clear();
req.rejectFile();
senderStatusListener.waitForEvent(4000);
receiverFTListerner.waitForEvent(4000);
// receiver
assertEquals("A file transfer rejected must be " +
"received on receiver side"
, 1, receiverFTListerner.collectedEvents.size());
fileTransferRequestEvent = (FileTransferRequestEvent)
receiverFTListerner.collectedEvents.get(0);
assertTrue("FileTransfer must be rejected"
,receiverFTListerner.isRejected());
// sender
assertEquals("A file transfer status changed - " +
"refused received on send side"
, 1, senderStatusListener.collectedEvents.size());
fileTransferStatusEvent
= senderStatusListener.collectedEvents.get(0);
assertTrue("Event must be refused (or failed)"
,(fileTransferStatusEvent.getNewStatus()
== FileTransferStatusChangeEvent.REFUSED)
|| (fileTransferStatusEvent.getNewStatus()
== FileTransferStatusChangeEvent.FAILED));
}
finally
{
ftOpSet1.removeFileTransferListener(senderFTListerner);
ftOpSet2.addFileTransferListener(receiverFTListerner);
}
}
/**
* When the transfer starts waits for a while and the receiver
* cancels the transfer while its in progress.
*
* @throws Exception
*/
public void testReceiverCancelsWhileTransfering()
throws Exception
{
if(!enableTestReceiverCancelsWhileTransfering())
return;
logger.trace("Start test : receiver will cancel " +
"fileTransfer whil transfering.");
File fileToTransfer = getTempFileToTransfer(12345678);
OperationSetFileTransfer ftOpSet1 = getOpSetFilTransfer1();
OperationSetFileTransfer ftOpSet2 = getOpSetFilTransfer2();
FileTransferStatusEventCollector senderStatusListener =
new FileTransferStatusEventCollector("Sender");
FileTransferEventCollector senderFTListerner =
new FileTransferEventCollector("Sender", senderStatusListener);
ftOpSet1.addFileTransferListener(senderFTListerner);
FileTransferStatusEventCollector receiverStatusListener =
new FileTransferStatusEventCollector("Receiver");
FileTransferEventCollector receiverFTListerner =
new FileTransferEventCollector("Receiver", receiverStatusListener);
ftOpSet2.addFileTransferListener(receiverFTListerner);
try
{
ftOpSet1.sendFile(getContact1(), fileToTransfer);
senderFTListerner.waitForEvent(4000);
receiverFTListerner.waitForEvent(4000);
senderStatusListener.waitForEvent(4000);
// sender
assertEquals("A file transfer created must be received on send side"
, 1, senderFTListerner.collectedEvents.size());
FileTransferCreatedEvent fileTransferCreatedEvent
= (FileTransferCreatedEvent)
senderFTListerner.collectedEvents.get(0);
assertEquals("FileTransfer file"
,fileTransferCreatedEvent.
getFileTransfer().getLocalFile()
,fileToTransfer);
assertEquals("A file transfer status changed - " +
"preparing received on send side"
, 1, senderStatusListener.collectedEvents.size());
FileTransferStatusChangeEvent fileTransferStatusEvent
= senderStatusListener.collectedEvents.get(0);
assertEquals("Event must be preparing"
,FileTransferStatusChangeEvent.PREPARING
,fileTransferStatusEvent.getNewStatus());
// receiver
assertEquals("A file transfer request must be " +
"received on the receiver side"
, 1, receiverFTListerner.collectedEvents.size());
FileTransferRequestEvent fileTransferRequestEvent
= (FileTransferRequestEvent)
receiverFTListerner.collectedEvents.get(0);
IncomingFileTransferRequest req =
fileTransferRequestEvent.getRequest();
assertEquals("FileTransfer file name must be the same"
,req.getFileName()
,fileToTransfer.getName());
assertEquals("FileTransfer file size must be the same"
,req.getFileSize()
,fileToTransfer.length());
// now we will accpet the file
// but let first clear the event listeners
senderFTListerner.clear();
receiverFTListerner.clear();
senderStatusListener.clear();
File receiveFile = getFileService().getTemporaryFile();
final FileTransfer ft2 = req.acceptFile(receiveFile);
// wait for preapring
receiverStatusListener.waitForEvent(16000, 1);
assertTrue("A file transfer status changed - " +
"preparing or and inProgress received on receiver side"
, receiverStatusListener.collectedEvents.size() >= 1);
FileTransferStatusChangeEvent stat1 =
receiverStatusListener.collectedEvents.get(0);
assertEquals("Event must be preparing"
,FileTransferStatusChangeEvent.PREPARING
,stat1.getNewStatus());
// now wait if some protocol fires inProgress
// jabber doesn't fire inProgress here
receiverStatusListener.waitForEvent(14000);
// wait in_progress
senderStatusListener.waitForEvent(14000);
receiverStatusListener.collectedEvents.clear();
senderStatusListener.clear();
ft2.cancel();
// now wait for cancel
receiverStatusListener.waitForEvent(14000);
FileTransferStatusChangeEvent stat3 =
receiverStatusListener.collectedEvents.get(0);
assertEquals("Event must be canceled"
,FileTransferStatusChangeEvent.CANCELED
,stat3.getNewStatus());
receiverFTListerner.waitForEvent(14000);
//receiver
assertEquals("A file transfer created must be " +
"received on receiver side"
, 1, receiverFTListerner.collectedEvents.size());
fileTransferCreatedEvent = (FileTransferCreatedEvent)
receiverFTListerner.collectedEvents.get(0);
assertEquals("FileTransfer file"
,fileTransferCreatedEvent.
getFileTransfer().getLocalFile()
,receiveFile);
// sender
senderStatusListener.waitForEvent(14000, 2);
assertTrue("Must contain canceled event",
senderStatusListener.contains(
FileTransferStatusChangeEvent.CANCELED));
}
finally
{
ftOpSet1.removeFileTransferListener(senderFTListerner);
ftOpSet2.addFileTransferListener(receiverFTListerner);
}
}
/**
* When the transfer starts waits for a while and the sender
* cancels the transfer while its in progress.
*
* @throws Exception
*/
public void testSenderCancelsWhileTransfering()
throws Exception
{
if(!enableTestSenderCancelsWhileTransfering())
return;
logger.trace("Start test : Sender will cancel fileTransfer" +
" while transfering.");
File fileToTransfer = getTempFileToTransfer(12345678);
OperationSetFileTransfer ftOpSet1 = getOpSetFilTransfer1();
OperationSetFileTransfer ftOpSet2 = getOpSetFilTransfer2();
FileTransferStatusEventCollector senderStatusListener =
new FileTransferStatusEventCollector("Sender");
FileTransferEventCollector senderFTListerner =
new FileTransferEventCollector("Sender", senderStatusListener);
ftOpSet1.addFileTransferListener(senderFTListerner);
FileTransferEventCollector receiverFTListerner =
new FileTransferEventCollector("Receiver", null);
ftOpSet2.addFileTransferListener(receiverFTListerner);
try
{
FileTransfer ft1 = ftOpSet1.sendFile(getContact1(), fileToTransfer);
senderFTListerner.waitForEvent(4000);
receiverFTListerner.waitForEvent(4000);
senderStatusListener.waitForEvent(4000);
// sender
assertEquals("A file transfer created must be received on send side"
, 1, senderFTListerner.collectedEvents.size());
FileTransferCreatedEvent fileTransferCreatedEvent
= (FileTransferCreatedEvent)
senderFTListerner.collectedEvents.get(0);
assertEquals("FileTransfer file"
,fileTransferCreatedEvent.
getFileTransfer().getLocalFile()
,fileToTransfer);
assertEquals("A file transfer status changed - " +
"preparing received on send side"
, 1, senderStatusListener.collectedEvents.size());
FileTransferStatusChangeEvent fileTransferStatusEvent
= senderStatusListener.collectedEvents.get(0);
assertEquals("Event must be preparing"
,FileTransferStatusChangeEvent.PREPARING
,fileTransferStatusEvent.getNewStatus());
// receiver
assertEquals("A file transfer request must be " +
"received on the receiver side"
, 1, receiverFTListerner.collectedEvents.size());
FileTransferRequestEvent fileTransferRequestEvent
= (FileTransferRequestEvent)
receiverFTListerner.collectedEvents.get(0);
IncomingFileTransferRequest req =
fileTransferRequestEvent.getRequest();
assertEquals("FileTransfer file name must be the same"
,req.getFileName()
,fileToTransfer.getName());
assertEquals("FileTransfer file size must be the same"
,req.getFileSize()
,fileToTransfer.length());
// now we will accpet the file
// but let first clear the event listeners
senderFTListerner.clear();
receiverFTListerner.clear();
senderStatusListener.clear();
File receiveFile = getFileService().getTemporaryFile();
FileTransferStatusEventCollector receiverStatusListener =
new FileTransferStatusEventCollector("Receiver");
final FileTransfer ft2 = req.acceptFile(receiveFile);
ft2.addStatusListener(receiverStatusListener);
// sender
// now wait for progress
senderStatusListener.waitForEvent(4000);
FileTransferStatusChangeEvent stat1 =
senderStatusListener.collectedEvents.get(0);
senderStatusListener.collectedEvents.clear();
assertEquals("Event must be inProgress"
,FileTransferStatusChangeEvent.IN_PROGRESS
,stat1.getNewStatus());
ft1.cancel();
// now wait for cancel
senderStatusListener.waitForEvent(4000);
FileTransferStatusChangeEvent stat2 =
senderStatusListener.collectedEvents.get(0);
senderStatusListener.collectedEvents.clear();
assertEquals("Event must be canceled"
,FileTransferStatusChangeEvent.CANCELED
,stat2.getNewStatus());
//receiver
receiverFTListerner.waitForEvent(4000);
assertEquals("A file transfer created must be received on " +
"receiver side"
, 1, receiverFTListerner.collectedEvents.size());
fileTransferCreatedEvent = (FileTransferCreatedEvent)
receiverFTListerner.collectedEvents.get(0);
assertEquals("FileTransfer file"
,fileTransferCreatedEvent.
getFileTransfer().getLocalFile()
,receiveFile);
receiverStatusListener.waitForEvent(4000, 3);
assertTrue("Cancel event must be received",
receiverStatusListener.contains(
FileTransferStatusChangeEvent.CANCELED));
}
finally
{
ftOpSet1.removeFileTransferListener(senderFTListerner);
ftOpSet2.addFileTransferListener(receiverFTListerner);
}
}
private static String statusToString(int s)
{
switch(s)
{
case FileTransferStatusChangeEvent.CANCELED : return "canceled";
case FileTransferStatusChangeEvent.COMPLETED : return "completed";
case FileTransferStatusChangeEvent.FAILED : return "failed";
case FileTransferStatusChangeEvent.IN_PROGRESS :
return "in_progress";
case FileTransferStatusChangeEvent.PREPARING : return "preparing";
case FileTransferStatusChangeEvent.REFUSED : return "refused";
default : return "waiting";
}
}
public abstract void start() throws Exception;
public abstract BundleContext getContext();
public abstract Contact getContact1();
public abstract Contact getContact2();
public abstract OperationSetFileTransfer getOpSetFilTransfer1();
public abstract OperationSetFileTransfer getOpSetFilTransfer2();
public abstract boolean enableTestSendAndReceive();
public abstract boolean enableTestSenderCancelBeforeAccepted();
public abstract boolean enableTestReceiverDecline();
public abstract boolean enableTestReceiverCancelsWhileTransfering();
public abstract boolean enableTestSenderCancelsWhileTransfering();
public abstract void stop() throws Exception;
/**
* Allows tests to wait for and collect events issued upon creation and
* reception of files.
*/
public class FileTransferEventCollector
implements FileTransferListener
{
public final List<EventObject> collectedEvents
= new ArrayList<EventObject>();
private boolean rejected = false;
private boolean canceled = false;
private FileTransferStatusEventCollector statusCollector = null;
private String name = null;
/**
* Creates an instance of this call event collector and registers it
* with listenedOpSet.
* @param name of collector
* @param statusCollector the event collector
*/
public FileTransferEventCollector(
String name, FileTransferStatusEventCollector statusCollector)
{
this.name = name;
this.statusCollector = statusCollector;
}
/**
* Blocks until at least one event is received or until waitFor
* miliseconds pass (whichever happens first).
*
* @param waitFor the number of miliseconds that we should be waiting
* for an event before simply bailing out.
*/
public void waitForEvent(long waitFor)
{
logger.trace("Waiting for a FileTransferEvent");
synchronized(this)
{
if(collectedEvents.size() > 0){
logger.trace("Event already received. " + collectedEvents);
return;
}
try{
wait(waitFor);
if(collectedEvents.size() > 0)
logger.trace("Received a FileTransferEvent.");
else
logger.trace("No FileTransferEvent received for "+waitFor+"ms.");
}
catch (InterruptedException ex)
{
logger.debug(
"Interrupted while waiting for a FileTransferEvent", ex);
}
}
}
/**
* Stores the received event and notifies all waiting on this object
* @param event the event
*/
public void fileTransferRequestReceived(FileTransferRequestEvent event)
{
synchronized(this)
{
logger.debug(
name + " Collected evt("+collectedEvents.size()+")= "+event);
this.collectedEvents.add(event);
notifyAll();
}
}
/**
* Stores the received event and notifies all waiting on this object
* @param event the event
*/
public void fileTransferCreated(FileTransferCreatedEvent event)
{
synchronized(this)
{
logger.debug(
name + " Collected evt("+collectedEvents.size()+")= "+event);
if(statusCollector != null)
{
event.getFileTransfer().addStatusListener(statusCollector);
}
this.collectedEvents.add(event);
notifyAll();
}
}
/**
* Stores the received event and notifies all waiting on this object
* @param event the event
*/
public void fileTransferRequestRejected(FileTransferRequestEvent event)
{
synchronized(this)
{
logger.debug(
name + " Collected evt("+collectedEvents.size()+")= "+event);
rejected = true;
this.collectedEvents.add(event);
notifyAll();
}
}
public void fileTransferRequestCanceled(FileTransferRequestEvent event)
{
synchronized(this)
{
logger.debug(
name + " Collected evt("+collectedEvents.size()+")= "+event);
canceled = true;
this.collectedEvents.add(event);
notifyAll();
}
}
public void clear()
{
collectedEvents.clear();
rejected = false;
}
/**
* @return the rejected
*/
public boolean isRejected()
{
return rejected;
}
/**
* @return the rejected
*/
public boolean isCanceled()
{
return canceled;
}
}
/**
* Allows tests to wait for and collect events issued upon creation and
* reception of files.
*/
public class FileTransferStatusEventCollector
implements FileTransferStatusListener
{
public ArrayList<FileTransferStatusChangeEvent> collectedEvents =
new ArrayList<FileTransferStatusChangeEvent>();
private String name = null;
private int eventsNum = 1;
FileTransferStatusEventCollector(String name)
{
this.name = name;
}
/**
* Blocks until at least one event is received or until waitFor
* miliseconds pass (whichever happens first).
*
* @param waitFor the number of miliseconds that we should be waiting
* for an event before simply bailing out.
* @param eventsNum number of events to wait for
*/
public void waitForEvent(long waitFor, int eventsNum)
{
this.eventsNum = eventsNum;
logger.trace("Waiting for a FileTransfer Status Event");
synchronized(this)
{
if(collectedEvents.size() > (eventsNum - 1))
{
logger.trace("Event already received. " + collectedEvents);
return;
}
try
{
wait(waitFor);
if(collectedEvents.size() > (eventsNum - 1))
logger.trace("Received a FileTransferEvent.");
else
logger.trace("Not enough FileTransferEvent received for"
+ waitFor + "ms.");
}
catch (InterruptedException ex)
{
logger.debug(
"Interrupted while waiting for a FileTransferEvent", ex);
}
}
}
/**
* Blocks until at least one event is received or until waitFor
* miliseconds pass (whichever happens first).
*
* @param waitFor the number of miliseconds that we should be waiting
* for an event before simply bailing out.
*/
public void waitForEvent(long waitFor)
{
waitForEvent(waitFor, 1);
}
/**
* Stores the received event and notifies all waiting on this object
* @param event the event
*/
public void statusChanged(FileTransferStatusChangeEvent event)
{
synchronized(this)
{
logger.debug(
name + " Collected evt("+collectedEvents.size()+")= "+event
+" status:"+statusToString(event.getNewStatus()));
this.collectedEvents.add(event);
// notifies that waiting for collecting events must stop
// only if the needed number of events is collected
if(collectedEvents.size() == eventsNum)
notifyAll();
}
}
public boolean contains(int status)
{
synchronized(this)
{
Iterator<FileTransferStatusChangeEvent>
iter = collectedEvents.iterator();
String statuses = "";
while (iter.hasNext())
{
FileTransferStatusChangeEvent e = iter.next();
if(e.getNewStatus() == status)
return true;
statuses += e.getNewStatus() + " ";
}
logger.warn("Status not found : " + status +
" between statuses : " + statuses);
return false;
}
}
/**
* clears the received events and sets the initial value of
* eventsNum.
*/
public void clear()
{
collectedEvents.clear();
eventsNum = 1;
}
}
}