diff --git a/build.xml b/build.xml
index 0da0f9e21..30a43a5ce 100644
--- a/build.xml
+++ b/build.xml
@@ -809,7 +809,7 @@
bundle-plugin-simpleaccreg,bundle-plugin-generalconfig,
bundle-plugin-googletalkaccregwizz,bundle-argdelegation-service,
bundle-argdelegation,bundle-zrtp4j,
- bundle-filehistory,bundle-metahistory"/>
+ bundle-filehistory,bundle-metahistory,bundle-metahistory-slick"/>
@@ -1988,5 +1988,14 @@ javax.swing.event, javax.swing.border"/>
prefix="net/java/sip/communicator/impl/metahistory" />
+
+
+
+
+
+
+
diff --git a/lib/felix.unit.test.properties b/lib/felix.unit.test.properties
index fc4347c8b..3f5525431 100644
--- a/lib/felix.unit.test.properties
+++ b/lib/felix.unit.test.properties
@@ -106,6 +106,8 @@ felix.auto.start.6= \
reference:file:sc-bundles/meta-cl.jar \
reference:file:sc-bundles/msghistory.jar \
reference:file:sc-bundles/callhistory.jar \
+ reference:file:sc-bundles/filehistory.jar \
+ reference:file:sc-bundles/metahistory.jar \
reference:file:sc-bundles/notification.jar \
reference:file:sc-bundles/osdependent.jar
@@ -125,6 +127,7 @@ felix.auto.start.7= \
reference:file:sc-bundles/protocol-icq-slick.jar \
reference:file:sc-bundles/protocol-rss-slick.jar \
reference:file:sc-bundles/msghistory-slick.jar \
+ reference:file:sc-bundles/metahistory-slick.jar \
reference:file:sc-bundles/callhistory-slick.jar \
reference:file:sc-bundles/popupmessagehandler-slick.jar
diff --git a/lib/testing.properties b/lib/testing.properties
index 8ac06de39..002b83184 100644
--- a/lib/testing.properties
+++ b/lib/testing.properties
@@ -9,21 +9,22 @@
# n.b. a multi-line continuation is marked with {white-space + back-slash + newline}.
# Comments cannot be embedded in a multi-line value list!
#
-net.java.sip.communicator.slick.runner.TEST_LIST=ConfigurationServiceLick \
- MetaContactListServiceLick \
- NetworkAddressManagerServiceLick \
- FileAccessServiceLick \
- HistoryServiceLick \
- SlicklessTests \
- MsgHistoryServiceLick \
- CallHistoryServiceLick \
- JabberProtocolProviderSlick \
- YahooProtocolProviderSlick \
- MsnProtocolProviderSlick \
- GibberishProtocolProviderServiceLick \
- RssProtocolProviderServiceLick \
- PopupMessageHandlerSLick
+net.java.sip.communicator.slick.runner.TEST_LIST=MetaHistoryServiceSLick
+#ConfigurationServiceLick \
+# MetaContactListServiceLick \
+# NetworkAddressManagerServiceLick \
+# FileAccessServiceLick \
+# HistoryServiceLick \
+# SlicklessTests \
+# MsgHistoryServiceLick \
+# CallHistoryServiceLick \
+# JabberProtocolProviderSlick \
+# YahooProtocolProviderSlick \
+# MsnProtocolProviderSlick \
+# GibberishProtocolProviderServiceLick \
+# RssProtocolProviderServiceLick \
+# PopupMessageHandlerSLick
# Note that NetworkAddressManagerServiceLick currently runs
# successfully because it sets up ZERO tests - the
diff --git a/src/net/java/sip/communicator/impl/history/HistoryWriterImpl.java b/src/net/java/sip/communicator/impl/history/HistoryWriterImpl.java
index 448fb1f3c..fb8d124f1 100644
--- a/src/net/java/sip/communicator/impl/history/HistoryWriterImpl.java
+++ b/src/net/java/sip/communicator/impl/history/HistoryWriterImpl.java
@@ -221,10 +221,10 @@ public void updateRecord(String idProperty, String idValue,
throws IOException
{
Iterator fileIterator = this.historyImpl.getFileList();
-
+ String filename = null;
while (fileIterator.hasNext())
{
- String filename = fileIterator.next();
+ filename = fileIterator.next();
Document doc = this.historyImpl.getDocumentForFile(filename);
@@ -284,10 +284,15 @@ public void updateRecord(String idProperty, String idValue,
// write changes
synchronized (this.docWriteLock)
{
- if(historyImpl.getHistoryServiceImpl().isCacheEnabled())
- this.historyImpl.writeFile(filename);
- else
- this.historyImpl.writeFile(filename, doc);
+ this.historyImpl.writeFile(filename, doc);
+ }
+
+ // this prevents that the current writer, which holds
+ // instance for the last document he is editing will not
+ // override our last changes to the document
+ if(filename.equals(this.currentFile))
+ {
+ this.currentDoc = doc;
}
break;
diff --git a/src/net/java/sip/communicator/impl/metahistory/MetaHistoryServiceImpl.java b/src/net/java/sip/communicator/impl/metahistory/MetaHistoryServiceImpl.java
index fd55badc2..5ee476bf9 100644
--- a/src/net/java/sip/communicator/impl/metahistory/MetaHistoryServiceImpl.java
+++ b/src/net/java/sip/communicator/impl/metahistory/MetaHistoryServiceImpl.java
@@ -342,7 +342,7 @@ else if(serv instanceof CallHistoryService)
{
CallRecord callRecord = iter.next();
- if(matchAnyCallParticipant(
+ if(matchCallParticipant(
callRecord.getParticipantRecords(), keywords, caseSensitive))
result.add(callRecord);
}
@@ -479,7 +479,7 @@ else if(serv instanceof CallHistoryService)
{
CallRecord callRecord = iter.next();
- if(matchAnyCallParticipant(
+ if(matchCallParticipant(
callRecord.getParticipantRecords(), keywords, caseSensitive))
result.add(callRecord);
}
@@ -557,7 +557,13 @@ else if(serv instanceof CallHistoryService)
}
listenWrapper.fireLastProgress(null, null, null);
- return result;
+ LinkedList resultAsList = new LinkedList(result);
+ int startIndex = resultAsList.size() - count;
+
+ if(startIndex < 0)
+ startIndex = 0;
+
+ return resultAsList.subList(startIndex, resultAsList.size());
}
/**
@@ -627,7 +633,10 @@ else if(serv instanceof CallHistoryService)
Collection col = chs.findByStartDate(date);
if(col.size() > count)
{
+ // before we make a sublist make sure there are sorted in the
+ // right order
List l = new LinkedList(col);
+ Collections.sort(l, new RecordsComparator());
result.addAll(l.subList(0, count));
}
else
@@ -636,8 +645,13 @@ else if(serv instanceof CallHistoryService)
}
}
listenWrapper.fireLastProgress(date, null, null);
+ LinkedList resultAsList = new LinkedList(result);
- return result;
+ int toIndex = count;
+ if(toIndex > resultAsList.size())
+ toIndex = resultAsList.size();
+
+ return resultAsList.subList(0, toIndex);
}
/**
@@ -717,7 +731,13 @@ else if(serv instanceof CallHistoryService)
}
listenWrapper.fireLastProgress(date, null, null);
- return result;
+ LinkedList resultAsList = new LinkedList(result);
+ int startIndex = resultAsList.size() - count;
+
+ if(startIndex < 0)
+ startIndex = 0;
+
+ return resultAsList.subList(startIndex, resultAsList.size());
}
/**
@@ -781,6 +801,50 @@ else if(callParticipant.getParticipantAddress().toLowerCase().
return false;
}
+ private boolean matchCallParticipant(
+ List cps, String[] keywords, boolean caseSensitive)
+ {
+ Iterator iter = cps.iterator();
+ while (iter.hasNext())
+ {
+ boolean match = false;
+ CallParticipantRecord callParticipant = iter.next();
+ for (int i = 0; i < keywords.length; i++)
+ {
+ String k = keywords[i];
+
+ if(caseSensitive)
+ {
+ if(callParticipant.getParticipantAddress().contains(k))
+ {
+ match = true;
+ }
+ else
+ {
+ match = false;
+ break;
+ }
+
+ continue;
+ }
+ else if(callParticipant.getParticipantAddress().toLowerCase().
+ contains(k.toLowerCase()))
+ {
+ match = true;
+ }
+ else
+ {
+ match = false;
+ break;
+ }
+ }
+
+ if(match) return true;
+ }
+
+ return false;
+ }
+
public void serviceChanged(ServiceEvent serviceEvent)
{
if(serviceEvent.getType() == ServiceEvent.UNREGISTERING)
diff --git a/src/net/java/sip/communicator/impl/protocol/mock/MockFileTransferImpl.java b/src/net/java/sip/communicator/impl/protocol/mock/MockFileTransferImpl.java
new file mode 100644
index 000000000..b78ec9cdb
--- /dev/null
+++ b/src/net/java/sip/communicator/impl/protocol/mock/MockFileTransferImpl.java
@@ -0,0 +1,73 @@
+/*
+ * SIP Communicator, the OpenSource Java VoIP and Instant Messaging client.
+ *
+ * Distributable under LGPL license.
+ * See terms of license at gnu.org.
+ */
+package net.java.sip.communicator.impl.protocol.mock;
+
+import java.io.*;
+import net.java.sip.communicator.service.protocol.*;
+import net.java.sip.communicator.service.protocol.event.*;
+
+/**
+ *
+ * @author Damian Minkov
+ */
+public class MockFileTransferImpl
+ extends AbstractFileTransfer
+{
+ private String id = null;
+ private int direction;
+ private File file = null;
+ private Contact contact = null;
+
+ public MockFileTransferImpl(Contact c, File file, String id, int direction)
+ {
+ this.id = id;
+ this.direction = direction;
+ this.file = file;
+ this.contact = c;
+ }
+
+ /**
+ * Notifies all status listeners that a new
+ * FileTransferStatusChangeEvent occured.
+ */
+ public void fireStatusChangeEvent(int newStatus)
+ {
+ super.fireStatusChangeEvent(newStatus);
+ }
+
+ @Override
+ public void cancel()
+ {
+ fireStatusChangeEvent(FileTransferStatusChangeEvent.CANCELED);
+ }
+
+ @Override
+ public long getTransferedBytes()
+ {
+ return 1;
+ }
+
+ public String getID()
+ {
+ return id;
+ }
+
+ public int getDirection()
+ {
+ return direction;
+ }
+
+ public File getFile()
+ {
+ return file;
+ }
+
+ public Contact getContact()
+ {
+ return contact;
+ }
+}
diff --git a/src/net/java/sip/communicator/impl/protocol/mock/MockOperationSetFileTransfer.java b/src/net/java/sip/communicator/impl/protocol/mock/MockOperationSetFileTransfer.java
new file mode 100644
index 000000000..30a54c845
--- /dev/null
+++ b/src/net/java/sip/communicator/impl/protocol/mock/MockOperationSetFileTransfer.java
@@ -0,0 +1,234 @@
+package net.java.sip.communicator.impl.protocol.mock;
+
+import java.io.*;
+
+import java.util.*;
+import net.java.sip.communicator.service.protocol.*;
+import net.java.sip.communicator.service.protocol.event.*;
+import net.java.sip.communicator.util.*;
+
+/**
+ * A mock implementation of a basic telephony opearation set
+ *
+ * @author Damian Minkov
+ */
+public class MockOperationSetFileTransfer
+ implements OperationSetFileTransfer
+{
+ private static final Logger logger =
+ Logger.getLogger(MockOperationSetFileTransfer.class);
+
+ /**
+ * A list of listeners registered for file transfer events.
+ */
+ private Vector fileTransferListeners
+ = new Vector();
+
+ /**
+ * A reference to the ProtocolProviderServiceSipImpl instance
+ * that created us.
+ */
+ private MockProvider protocolProvider = null;
+
+ public MockOperationSetFileTransfer(MockProvider protocolProvider)
+ {
+ this.protocolProvider = protocolProvider;
+ }
+
+ /**
+ * Sends a file transfer request to the given toContact by
+ * specifying the local and remote file path and the fromContact,
+ * sending the file.
+ *
+ * @return the transfer object
+ *
+ * @param toContact the contact that should receive the file
+ * @param fromContact the contact sending the file
+ * @param remotePath the remote file path
+ * @param localPath the local file path
+ */
+ public FileTransfer sendFile(Contact toContact, File file)
+ throws IllegalStateException,
+ IllegalArgumentException
+ {
+ MockFileTransferImpl fileTrans = new MockFileTransferImpl(
+ toContact,
+ file,
+ generateID(),
+ FileTransfer.OUT);
+
+ fireFileTransferCreated(new FileTransferCreatedEvent(fileTrans, new Date()));
+
+ changeFileTransferStatus(fileTrans, FileTransferStatusChangeEvent.PREPARING);
+
+ return fileTrans;
+ }
+
+ public void changeFileTransferStatus(FileTransfer ft, int newstatus)
+ {
+ ((MockFileTransferImpl)ft).fireStatusChangeEvent(newstatus);
+ }
+
+ private String generateID()
+ {
+ return String.valueOf( System.currentTimeMillis()) +
+ String.valueOf(hashCode());
+ }
+
+ public void receiveFile(final File file,
+ final Contact from)
+ {
+ final Date requestDate = new Date();
+
+ final String id = generateID();
+
+ fireFileTransferRequest(
+ new FileTransferRequestEvent(
+ new IncomingFileTransferRequest()
+ {
+ public String getID()
+ {
+ return id;
+ }
+
+ public String getFileName()
+ {
+ return file.getName();
+ }
+
+ public String getFileDescription()
+ {
+ return file.toString();
+ }
+
+ public long getFileSize()
+ {
+ return file.length();
+ }
+
+ public Contact getSender()
+ {
+ return from;
+ }
+
+ public FileTransfer acceptFile(File file)
+ {
+ MockFileTransferImpl fileTrans =
+ new MockFileTransferImpl(
+ from,
+ file,
+ id,
+ FileTransfer.IN);
+
+ fireFileTransferCreated(
+ new FileTransferCreatedEvent(fileTrans, requestDate));
+
+ changeFileTransferStatus(fileTrans,
+ FileTransferStatusChangeEvent.PREPARING);
+
+ return fileTrans;
+ }
+
+ public void rejectFile()
+ {
+
+ }
+ }, requestDate));
+ }
+
+ /**
+ * Sends a file transfer request to the given toContact by
+ * specifying the local and remote file path and the fromContact,
+ * sending the file.
+ *
+ * @return the transfer object
+ *
+ * @param toContact the contact that should receive the file
+ * @param fromContact the contact sending the file
+ * @param remotePath the remote file path
+ * @param localPath the local file path
+ */
+ public FileTransfer sendFile(Contact toContact, Contact fromContact, String remotePath, String localPath)
+ throws IllegalStateException,
+ IllegalArgumentException
+ {
+ return this.sendFile(toContact, new File(localPath));
+ }
+
+ /**
+ * Adds the given FileTransferListener that would listen for
+ * file transfer requests and created file transfers.
+ *
+ * @param listener the FileTransferListener to add
+ */
+ public void addFileTransferListener(FileTransferListener listener)
+ {
+ synchronized(fileTransferListeners)
+ {
+ if(!fileTransferListeners.contains(listener))
+ {
+ this.fileTransferListeners.add(listener);
+ }
+ }
+ }
+
+ /**
+ * Removes the given FileTransferListener that listens for
+ * file transfer requests and created file transfers.
+ *
+ * @param listener the FileTransferListener to remove
+ */
+ public void removeFileTransferListener(FileTransferListener listener)
+ {
+ synchronized(fileTransferListeners)
+ {
+ this.fileTransferListeners.remove(listener);
+ }
+ }
+
+ /**
+ * Delivers the specified event to all registered file transfer listeners.
+ *
+ * @param event the EventObject that we'd like delivered to all
+ * registered file transfer listeners.
+ */
+ private void fireFileTransferRequest(FileTransferRequestEvent event)
+ {
+ Iterator listeners = null;
+ synchronized (fileTransferListeners)
+ {
+ listeners = new ArrayList
+ (fileTransferListeners).iterator();
+ }
+
+ while (listeners.hasNext())
+ {
+ FileTransferListener listener = listeners.next();
+
+ listener.fileTransferRequestReceived(event);
+ }
+ }
+
+ /**
+ * Delivers the file transfer to all registered listeners.
+ *
+ * @param fileTransfer the FileTransfer that we'd like delivered to
+ * all registered file transfer listeners.
+ */
+ void fireFileTransferCreated(FileTransferCreatedEvent event)
+ {
+ Iterator listeners = null;
+ synchronized (fileTransferListeners)
+ {
+ listeners = new ArrayList
+ (fileTransferListeners).iterator();
+ }
+
+ while (listeners.hasNext())
+ {
+ FileTransferListener listener = listeners.next();
+
+ listener.fileTransferCreated(event);
+ }
+ }
+}
diff --git a/src/net/java/sip/communicator/impl/protocol/mock/MockProvider.java b/src/net/java/sip/communicator/impl/protocol/mock/MockProvider.java
index cbdb3cfdb..ee7098774 100644
--- a/src/net/java/sip/communicator/impl/protocol/mock/MockProvider.java
+++ b/src/net/java/sip/communicator/impl/protocol/mock/MockProvider.java
@@ -78,6 +78,13 @@ public MockProvider(String userName)
this.supportedOperationSets.put(
OperationSetBasicTelephony.class.getName(),
mockTelphonyOpSet);
+
+ MockOperationSetFileTransfer mockFileTransferOpSet =
+ new MockOperationSetFileTransfer(this);
+
+ this.supportedOperationSets.put(
+ OperationSetFileTransfer.class.getName(),
+ mockFileTransferOpSet);
}
/**
diff --git a/src/net/java/sip/communicator/service/filehistory/FileHistoryService.java b/src/net/java/sip/communicator/service/filehistory/FileHistoryService.java
index 0f888366d..db136adfc 100644
--- a/src/net/java/sip/communicator/service/filehistory/FileHistoryService.java
+++ b/src/net/java/sip/communicator/service/filehistory/FileHistoryService.java
@@ -119,7 +119,7 @@ public Collection findByKeyword(
* @return Collection of FileRecords
* @throws RuntimeException
*/
- Collection findByKeyword(
+ public Collection findByKeyword(
MetaContact contact, String keyword, boolean caseSensitive)
throws RuntimeException;
diff --git a/test/net/java/sip/communicator/slick/msghistory/MetaHistoryServiceLick.java b/test/net/java/sip/communicator/slick/msghistory/MetaHistoryServiceLick.java
new file mode 100644
index 000000000..7b1d1482a
--- /dev/null
+++ b/test/net/java/sip/communicator/slick/msghistory/MetaHistoryServiceLick.java
@@ -0,0 +1,59 @@
+/*
+ * SIP Communicator, the OpenSource Java VoIP and Instant Messaging client.
+ *
+ * Distributable under LGPL license.
+ * See terms of license at gnu.org.
+ */
+package net.java.sip.communicator.slick.metahistory;
+
+import java.util.*;
+
+import org.osgi.framework.*;
+import junit.framework.*;
+import net.java.sip.communicator.util.*;
+
+/**
+ *
+ * @author Damian Minkov
+ */
+public class MetaHistoryServiceLick
+ extends TestSuite
+ implements BundleActivator
+{
+ private static Logger logger = Logger.getLogger(MetaHistoryServiceLick.class);
+
+ protected static BundleContext bc = null;
+
+ /**
+ * Start the File History Sevice Implementation Compatibility Kit.
+ *
+ * @param bundleContext
+ * BundleContext
+ * @throws Exception
+ */
+ public void start(BundleContext bundleContext)
+ throws Exception
+ {
+ MetaHistoryServiceLick.bc = bundleContext;
+
+ setName("MetaHistoryServiceSLick");
+ Hashtable properties = new Hashtable();
+ properties.put("service.pid", getName());
+
+ addTest(TestMetaHistoryService.suite());
+ bundleContext.registerService(getClass().getName(), this, properties);
+
+ logger.debug("Successfully registered " + getClass().getName());
+ }
+
+ /**
+ * stop
+ *
+ * @param bundlecontext BundleContext
+ * @throws Exception
+ */
+ public void stop(BundleContext bundlecontext)
+ throws Exception
+ {
+ }
+}
diff --git a/test/net/java/sip/communicator/slick/msghistory/TestMetaHistoryService.java b/test/net/java/sip/communicator/slick/msghistory/TestMetaHistoryService.java
new file mode 100644
index 000000000..bc839730a
--- /dev/null
+++ b/test/net/java/sip/communicator/slick/msghistory/TestMetaHistoryService.java
@@ -0,0 +1,1007 @@
+/*
+ * SIP Communicator, the OpenSource Java VoIP and Instant Messaging client.
+ *
+ * Distributable under LGPL license.
+ * See terms of license at gnu.org.
+ */
+package net.java.sip.communicator.slick.metahistory;
+
+import java.io.File;
+import java.util.*;
+
+import org.osgi.framework.*;
+import junit.framework.*;
+import net.java.sip.communicator.impl.protocol.mock.*;
+import net.java.sip.communicator.service.callhistory.CallHistoryService;
+import net.java.sip.communicator.service.callhistory.CallParticipantRecord;
+import net.java.sip.communicator.service.callhistory.CallRecord;
+import net.java.sip.communicator.service.contactlist.*;
+import net.java.sip.communicator.service.filehistory.FileHistoryService;
+import net.java.sip.communicator.service.filehistory.FileRecord;
+import net.java.sip.communicator.service.metahistory.*;
+import net.java.sip.communicator.service.msghistory.*;
+import net.java.sip.communicator.service.protocol.*;
+import net.java.sip.communicator.service.protocol.event.*;
+import net.java.sip.communicator.util.*;
+
+/**
+ * Tests file message history.
+ * First installs the MoxkProtocolProvider to be able to send some files
+ * The file history service stores them
+ * and then tests the verious find methods - does they find the messsages we have
+ * already sent
+ *
+ * @author Damian Minkov
+ */
+public class TestMetaHistoryService
+ extends TestCase
+{
+ private static final Logger logger = Logger.getLogger(TestMetaHistoryService.class);
+
+ static final String TEST_CONTACT_NAME_1 = "Mincho_Penchev_the_fisrt";
+ static final String TEST_CONTACT_NAME_2 = "Mincho_Penchev_the_second";
+
+// static final String TEST_ROOM_NAME = "test_room";
+
+ /**
+ * The provider that we use to make a dummy server-stored contactlist
+ * used for testing. The mockProvider is instantiated and registered
+ * by the metacontactlist slick activator.
+ */
+ public static MockProvider mockProvider = null;
+ /**
+ * The persistent presence operation set of the default mock provider.
+ */
+ public static MockPersistentPresenceOperationSet mockPresOpSet = null;
+ public static MockOperationSetFileTransfer mockFTOpSet = null;
+ public static MockBasicInstantMessaging mockBImOpSet = null;
+ public static MockOperationSetBasicTelephony mockBTelphonyOpSet = null;
+
+ private static ServiceReference metaHistoryServiceRef = null;
+ public static MetaHistoryService metaHistoryService = null;
+
+ private static MockContact testContact = null;
+
+ private static ServiceReference metaCLref = null;
+ private static MetaContactListService metaClService = null;
+
+ private static MetaContact testMetaContact = null;
+
+ /**
+ * A reference to the registration of the first mock provider.
+ */
+ public static ServiceRegistration mockPrServiceRegistration = null;
+
+ private static Message[] messagesToSend = null;
+
+ private static Date controlDate1 = null;
+ private static Date controlDate2 = null;
+
+ /**
+ * The addresses will be used in the generated mock calls
+ */
+ private static Vector participantAddresses = new Vector();
+
+ /**
+ * Files to receive
+ */
+ private static File[] files = null;
+
+ public TestMetaHistoryService(String name)
+ {
+ super(name);
+ }
+
+ public static Test suite()
+ {
+ TestSuite suite = new TestSuite();
+ suite.addTest(
+ new TestMetaHistoryService("setupContact"));
+ suite.addTest(
+ new TestMetaHistoryService("writeRecords"));
+ suite.addTest(
+ new TestMetaHistoryService("messageTests"));
+ suite.addTest(
+ new TestMetaHistoryService("callTests"));
+ suite.addTest(
+ new TestMetaHistoryService("fileTests"));
+ suite.addTest(
+ new TestMetaHistoryService("metaTests"));
+ suite.addTest(
+ new TestMetaHistoryService("testPurgeLocalContactListCopy"));
+
+ return suite;
+ }
+
+ protected void setUp() throws Exception
+ {
+ }
+
+ protected void tearDown() throws Exception
+ {
+ }
+
+ public void setupContact()
+ {
+ // changes the history service target derictory
+ System.setProperty("HistoryServiceDirectory", "test-filehistory");
+
+ mockProvider = new MockProvider("FileHistoryMockUser");
+
+ //store thre presence op set of the new provider into the fixture
+ Map supportedOperationSets =
+ mockProvider.getSupportedOperationSets();
+
+ //get the operation set presence here.
+ mockPresOpSet =
+ (MockPersistentPresenceOperationSet) supportedOperationSets.get(
+ OperationSetPersistentPresence.class.getName());
+
+ mockBTelphonyOpSet =
+ (MockOperationSetBasicTelephony) mockProvider
+ .getOperationSet(OperationSetBasicTelephony.class);
+
+ mockBImOpSet =
+ (MockBasicInstantMessaging) supportedOperationSets.get(
+ OperationSetBasicInstantMessaging.class.getName());
+
+ mockFTOpSet =
+ (MockOperationSetFileTransfer) supportedOperationSets.get(
+ OperationSetFileTransfer.class.getName());
+
+ metaHistoryServiceRef =
+ MetaHistoryServiceLick.bc.
+ getServiceReference(MetaHistoryService.class.getName());
+
+ metaHistoryService =
+ (MetaHistoryService)MetaHistoryServiceLick.bc.
+ getService(metaHistoryServiceRef);
+
+ // fill in a contact to comunicate with
+ MockContactGroup root =
+ (MockContactGroup)mockPresOpSet.getServerStoredContactListRoot();
+
+ testContact = new MockContact(TEST_CONTACT_NAME_1, mockProvider);
+ root.addContact(testContact);
+
+ metaCLref = MetaHistoryServiceLick.bc.getServiceReference(
+ MetaContactListService.class.getName());
+
+ metaClService =
+ (MetaContactListService)MetaHistoryServiceLick.bc.getService(metaCLref);
+
+ System.setProperty(MetaContactListService.PROVIDER_MASK_PROPERTY, "1");
+
+ Hashtable mockProvProperties = new Hashtable();
+ mockProvProperties.put(ProtocolProviderFactory.PROTOCOL
+ , mockProvider.getProtocolName());
+ mockProvProperties.put(MetaContactListService.PROVIDER_MASK_PROPERTY,
+ "1");
+
+ mockPrServiceRegistration =
+ MetaHistoryServiceLick.bc.registerService(
+ ProtocolProviderService.class.getName(),
+ mockProvider,
+ mockProvProperties);
+ logger.debug("Registered a mock protocol provider! ");
+
+ testMetaContact = metaClService.getRoot().
+ getMetaContact(mockProvider, TEST_CONTACT_NAME_1);
+
+ // add one more contact as specific problems may happen only when
+ // more than one contact is in the metacontact
+ metaClService.addNewContactToMetaContact(
+ mockProvider, testMetaContact, TEST_CONTACT_NAME_2);
+
+ messagesToSend = new Message[]
+ {
+ mockBImOpSet.createMessage("test message word1-" + Math.random()),
+ mockBImOpSet.createMessage("test message word2-" + Math.random()),
+ mockBImOpSet.createMessage("test message word3-" + Math.random()),
+ mockBImOpSet.createMessage(
+ "test message word4 participant_address_4 t4 -" + Math.random()),
+ mockBImOpSet.createMessage("test message word5-" + Math.random()),
+ mockBImOpSet.createMessage(
+ "test message word6 participant_address_1 t1 -" + Math.random())
+ };
+
+ participantAddresses.add("participant_address_1");
+ participantAddresses.add("participant_address_2");
+ participantAddresses.add("participant_address_3");
+ participantAddresses.add("participant_address_4");
+ participantAddresses.add("participant_address_5");
+ participantAddresses.add("participant_address_6");
+
+ files = new File[]
+ {
+ new File("t1.txt"),
+ new File("t2.txt"),
+ new File("t3.txt"),
+ new File("t4.txt"),
+ new File("t5.txt"),
+ new File("t6.txt")
+ };
+ }
+
+ /**
+ * First send the messages
+ */
+ public void writeRecords()
+ {
+ logger.info("write records ");
+
+ assertNotNull("No metacontact", testMetaContact);
+
+ // First cancel an out file transfer
+ FileTransfer ft = mockFTOpSet.sendFile(testContact, files[0]);
+ mockFTOpSet.changeFileTransferStatus(ft, FileTransferStatusChangeEvent.CANCELED);
+ // now receive a filetransfer and accept it
+ TransferListener tl = new TransferListener(files[1].getName(), true, true);
+ mockFTOpSet.addFileTransferListener(tl);
+ mockFTOpSet.receiveFile(files[1], testContact);
+ mockFTOpSet.removeFileTransferListener(tl);
+
+ generateCall((String)participantAddresses.get(0));
+ generateCall((String)participantAddresses.get(1));
+ mockBImOpSet.deliverMessage(TEST_CONTACT_NAME_1, messagesToSend[0]);
+ mockBImOpSet.deliverMessage(TEST_CONTACT_NAME_2, messagesToSend[1]);
+
+ controlDate1 = new Date();
+
+ waitSeconds(200);
+
+ generateCall((String)participantAddresses.get(2));
+ generateCall((String)participantAddresses.get(3));
+ mockBImOpSet.deliverMessage(TEST_CONTACT_NAME_1, messagesToSend[2]);
+ mockBImOpSet.deliverMessage(TEST_CONTACT_NAME_2, messagesToSend[3]);
+ // finish an out file transfer
+ ft = mockFTOpSet.sendFile(testContact, files[2]);
+ mockFTOpSet.changeFileTransferStatus(ft, FileTransferStatusChangeEvent.COMPLETED);
+ // now receive a filetransfer and decline it
+ tl = new TransferListener(files[3].getName(), false, false);
+ mockFTOpSet.addFileTransferListener(tl);
+ mockFTOpSet.receiveFile(files[3], testContact);
+ mockFTOpSet.removeFileTransferListener(tl);
+
+ controlDate2 = new Date();
+ waitSeconds(200);
+
+ generateCall((String)participantAddresses.get(4));
+ generateCall((String)participantAddresses.get(5));
+ // finish an out file transfer
+ ft = mockFTOpSet.sendFile(testContact, files[4]);
+ mockFTOpSet.changeFileTransferStatus(ft, FileTransferStatusChangeEvent.REFUSED);
+ // now receive a filetransfer and decline it
+ tl = new TransferListener(files[5].getName(), true, true);
+ mockFTOpSet.addFileTransferListener(tl);
+ mockFTOpSet.receiveFile(files[5], testContact);
+ mockFTOpSet.removeFileTransferListener(tl);
+ mockBImOpSet.deliverMessage(TEST_CONTACT_NAME_1, messagesToSend[4]);
+ mockBImOpSet.deliverMessage(TEST_CONTACT_NAME_2, messagesToSend[5]);
+ }
+
+ private void generateCall(String participant)
+ {
+ try
+ {
+ Call newCall = mockBTelphonyOpSet.placeCall(participant);
+
+ Vector v = new Vector();
+
+ Iterator iter = newCall.getCallParticipants();
+ while (iter.hasNext())
+ {
+ CallParticipant item = (CallParticipant) iter.next();
+ v.add(item);
+ }
+
+ waitSeconds(2000);
+
+ iter = v.iterator();
+ while (iter.hasNext())
+ {
+ CallParticipant item = (CallParticipant) iter.next();
+ mockBTelphonyOpSet.hangupCallParticipant(item);
+ }
+ }
+ catch (Exception ex1)
+ {
+ logger.error("Cannot place mock call", ex1);
+ fail("Cannot place mock call to " + participant);
+ }
+ }
+
+ private void waitSeconds(long secs)
+ {
+ Object lock = new Object();
+ synchronized (lock){
+ // wait a moment
+ try{
+ lock.wait(secs);
+ }
+ catch (InterruptedException ex){}
+ }
+ }
+
+ /**
+ * tests all read methods (finders)
+ */
+ public void messageTests()
+ {
+ /**
+ * This matches all written messages, they are minimum 5
+ */
+ Collection rs = metaHistoryService.findByKeyword(
+ new String[]{MessageHistoryService.class.getName()},
+ testMetaContact, "test");
+
+ assertTrue("Nothing found findByKeyword ", !rs.isEmpty());
+
+ Vector msgs = getMessages(rs);
+
+ assertTrue("Messages too few - findByKeyword", msgs.size() >= 5);
+
+ /**
+ * Will test case sernsitive and insensitive search
+ */
+ rs = metaHistoryService.findByKeyword(
+ new String[]{MessageHistoryService.class.getName()},
+ testMetaContact, "Test", false);
+
+ assertTrue("Nothing found findByKeyword caseINsensitive search", !rs.isEmpty());
+
+ msgs = getMessages(rs);
+
+ assertTrue("Messages too few - findByKeyword", msgs.size() >= 5);
+
+ rs = metaHistoryService.findByKeyword(
+ new String[]{MessageHistoryService.class.getName()},
+ testMetaContact, "Test", true);
+
+ assertFalse("Something found by findByKeyword casesensitive search", !rs.isEmpty());
+
+ /**
+ * This must match also many messages, as tests are run many times
+ * but the minimum is 3
+ */
+ rs = metaHistoryService.findByEndDate(
+ new String[]{MessageHistoryService.class.getName()},
+ testMetaContact, controlDate2);
+
+ assertTrue("Nothing found findByEndDate", !rs.isEmpty());
+
+ msgs = getMessages(rs);
+
+ assertTrue("Messages too few - findByEndDate", msgs.size() >= 3);
+
+ /**
+ * This must find also many messages but atleast one
+ */
+ rs = metaHistoryService.findByKeywords(
+ new String[]{MessageHistoryService.class.getName()},
+ testMetaContact,
+ new String[]{"test", "word2"});
+
+ assertTrue("Nothing found findByKeywords", !rs.isEmpty());
+ msgs = getMessages(rs);
+ assertTrue("Messages too few - findByKeywords", msgs.size() >= 1);
+
+ /**
+ * Nothing to be found
+ */
+ rs = metaHistoryService.findByKeywords(
+ new String[]{MessageHistoryService.class.getName()},
+ testMetaContact,
+ new String[]{"test1", "word2"});
+
+ assertFalse("Something found findByKeywords", !rs.isEmpty());
+
+ /**
+ * must find 2 messages
+ */
+ rs = metaHistoryService.findByPeriod(
+ new String[]{MessageHistoryService.class.getName()},
+ testMetaContact, controlDate1, controlDate2);
+
+ assertTrue("Nothing found findByPeriod", !rs.isEmpty());
+
+ msgs = getMessages(rs);
+
+ assertEquals("Messages must be 2", msgs.size(), 2);
+
+ assertTrue("Message no found",
+ msgs.contains(messagesToSend[2].getContent()));
+ assertTrue("Message no found",
+ msgs.contains(messagesToSend[3].getContent()));
+
+ /**
+ * must find 1 record
+ */
+ rs = metaHistoryService.findByPeriod(
+ new String[]{MessageHistoryService.class.getName()},
+ testMetaContact, controlDate1, controlDate2, new String[]{"word3"});
+
+ assertTrue("Nothing found findByPeriod", !rs.isEmpty());
+
+ msgs = getMessages(rs);
+
+ assertEquals("Messages must be 1", msgs.size(), 1);
+ assertTrue("Message no found",
+ msgs.contains(messagesToSend[2].getContent()));
+
+ /**
+ * must find 2 records
+ */
+ rs = metaHistoryService.findByStartDate(
+ new String[]{MessageHistoryService.class.getName()},
+ testMetaContact, controlDate2);
+
+ assertTrue("Nothing found findByStartDate", !rs.isEmpty());
+ msgs = getMessages(rs);
+ assertEquals("Messages must be 2", msgs.size(), 2);
+ assertTrue("Message no found",
+ msgs.contains(messagesToSend[4].getContent()));
+ assertTrue("Message no found",
+ msgs.contains(messagesToSend[5].getContent()));
+
+ /**
+ * Must return exactly the last 3 messages
+ */
+ rs = metaHistoryService.findLast(
+ new String[]{MessageHistoryService.class.getName()},
+ testMetaContact, 3);
+
+ assertTrue("Nothing found 8", !rs.isEmpty());
+ msgs = getMessages(rs);
+ assertEquals("Messages must be 3", msgs.size(), 3);
+ assertTrue("Message no found",
+ msgs.contains(messagesToSend[3].getContent()));
+ assertTrue("Message no found",
+ msgs.contains(messagesToSend[4].getContent()));
+ assertTrue("Message no found",
+ msgs.contains(messagesToSend[5].getContent()));
+
+ /**
+ * Must return exactly the 3 messages after controlDate1
+ */
+ rs = metaHistoryService.findFirstMessagesAfter(
+ new String[]{MessageHistoryService.class.getName()},
+ testMetaContact, controlDate1, 3);
+
+ assertTrue("Nothing found 9", !rs.isEmpty());
+ msgs = getMessages(rs);
+ assertEquals("Messages must be 3", msgs.size(), 3);
+ assertTrue("Message no found",
+ msgs.contains(messagesToSend[2].getContent()));
+ assertTrue("Message no found",
+ msgs.contains(messagesToSend[3].getContent()));
+ assertTrue("Message no found",
+ msgs.contains(messagesToSend[4].getContent()));
+
+ /**
+ * Must return exactly the 3 messages before controlDate2
+ */
+ rs = metaHistoryService.findLastMessagesBefore(
+ new String[]{MessageHistoryService.class.getName()},
+ testMetaContact, controlDate2, 3);
+
+ assertTrue("Nothing found 10", !rs.isEmpty());
+ msgs = getMessages(rs);
+ assertEquals("Messages must be 3", msgs.size(), 3);
+ assertTrue("Message no found",
+ msgs.contains(messagesToSend[1].getContent()));
+ assertTrue("Message no found",
+ msgs.contains(messagesToSend[2].getContent()));
+ assertTrue("Message no found",
+ msgs.contains(messagesToSend[3].getContent()));
+
+ }
+
+ public void callTests()
+ {
+ /**
+ * This must match also many calls, as tests are run many times
+ * but the minimum is 3
+ */
+ Collection rs = metaHistoryService.findByEndDate(
+ new String[]{CallHistoryService.class.getName()},
+ null,
+ controlDate2);
+ Iterator resultIter = getCalls(rs).iterator();
+
+ assertTrue("Calls too few - findByEndDate", rs.size() >= 3);
+
+ /**
+ * must find 2 calls
+ */
+ rs = metaHistoryService.findByPeriod(
+ new String[]{CallHistoryService.class.getName()},
+ null,
+ controlDate1, controlDate2);
+ resultIter = rs.iterator();
+
+ assertEquals("Calls must be 2", rs.size(), 2);
+
+ CallRecord rec = (CallRecord)resultIter.next();
+ CallParticipantRecord participant =
+ (CallParticipantRecord)rec.getParticipantRecords().get(0);
+
+ assertTrue("Participant incorrect ",
+ participant.getParticipantAddress().
+ equals(participantAddresses.get(2)));
+
+ rec = (CallRecord)resultIter.next();
+ participant = (CallParticipantRecord)rec.getParticipantRecords().get(0);
+
+ assertTrue("Participant incorrect ",
+ participant.getParticipantAddress().
+ equals(participantAddresses.get(3)));
+
+ /**
+ * must find 1 record
+ */
+ rs = metaHistoryService.findByStartDate(
+ new String[]{CallHistoryService.class.getName()},
+ null,
+ controlDate2);
+ resultIter = rs.iterator();
+
+ assertEquals("Calls must be 2", rs.size(), 2);
+
+ rec = (CallRecord)resultIter.next();
+ participant = (CallParticipantRecord)rec.getParticipantRecords().get(0);
+
+ assertTrue("Participant incorrect ",
+ participant.getParticipantAddress().
+ equals(participantAddresses.get(4)));
+
+ rec = (CallRecord)resultIter.next();
+ participant = (CallParticipantRecord)rec.getParticipantRecords().get(0);
+
+ assertTrue("Participant incorrect ",
+ participant.getParticipantAddress().
+ equals(participantAddresses.get(5)));
+
+ /**
+ * Must return exactly the last 3 calls
+ */
+ rs = metaHistoryService.findLast(
+ new String[]{CallHistoryService.class.getName()},
+ null,
+ 3);
+ resultIter = rs.iterator();
+
+ assertEquals("Calls must be 3", rs.size(), 3);
+
+ rec = (CallRecord)resultIter.next();
+ participant = (CallParticipantRecord) rec.getParticipantRecords().get(0);
+
+ assertTrue("Participant incorrect ",
+ participant.getParticipantAddress().
+ equals(participantAddresses.get(3)));
+
+ rec = (CallRecord)resultIter.next();
+ participant = (CallParticipantRecord) rec.getParticipantRecords().get(0);
+
+ assertTrue("Participant incorrect ",
+ participant.getParticipantAddress().
+ equals(participantAddresses.get(4)));
+
+ rec = (CallRecord)resultIter.next();
+ participant = (CallParticipantRecord) rec.getParticipantRecords().get(0);
+
+ assertTrue("Participant incorrect ",
+ participant.getParticipantAddress().
+ equals(participantAddresses.get(5)));
+ }
+
+ public void fileTests()
+ {
+ /**
+ * must find 4 results.
+ */
+ Collection rs =
+ getFileRecords(
+ metaHistoryService.findByStartDate(
+ new String[]{FileHistoryService.class.getName()},
+ testMetaContact, controlDate1));
+
+ assertEquals("Filetransfers must be 4", 4, rs.size());
+
+ rs = getFileRecords(
+ metaHistoryService.findByEndDate(
+ new String[]{FileHistoryService.class.getName()},
+ testMetaContact, controlDate2));
+ assertTrue("FileTransfers too few - findByEndDate", rs.size() >= 4);
+
+ rs = getFileRecords(
+ metaHistoryService.findByPeriod(
+ new String[]{FileHistoryService.class.getName()},
+ testMetaContact, controlDate1, controlDate2));
+ assertEquals("Filetransfers must be 2", rs.size(), 2);
+
+ Iterator it = rs.iterator();
+ assertTrue("Filetransfers not found",
+ ((FileRecord)it.next()).getFile().getName().
+ equals(files[2].getName()));
+ assertTrue("Filetransfers not found",
+ ((FileRecord)it.next()).getFile().getName().
+ equals(files[3].getName()));
+
+ rs = getFileRecords(
+ metaHistoryService.findByPeriod(
+ new String[]{FileHistoryService.class.getName()},
+ testMetaContact, controlDate1, controlDate2,
+ new String[]{"t3"}));
+ assertEquals("Filetransfers must be 1", rs.size(), 1);
+
+ it = rs.iterator();
+ assertTrue("Filetransfers not found",
+ ((FileRecord)it.next()).getFile().getName().
+ equals(files[2].getName()));
+
+ rs = getFileRecords(
+ metaHistoryService.findByPeriod(
+ new String[]{FileHistoryService.class.getName()},
+ testMetaContact, controlDate1, controlDate2,
+ new String[]{"T3"}, true));
+ assertEquals("Filetransfers must be 0", rs.size(), 0);
+
+ rs = getFileRecords(
+ metaHistoryService.findLast(
+ new String[]{FileHistoryService.class.getName()},
+ testMetaContact, 2));
+ assertEquals("Filetransfers must be 2", rs.size(), 2);
+
+ it = rs.iterator();
+ FileRecord fr = (FileRecord)it.next();
+ assertTrue("Filetransfers not found",
+ fr.getFile().getName().
+ equals(files[4].getName()));
+ System.out.println("--------- " + fr.getFile().getName());
+ System.out.println("--------- " + fr.getStatus());
+ assertTrue("Filetransfers status wrong",
+ fr.getStatus().
+ equals("refused"));
+ assertTrue("Filetransfers direction wrong",
+ fr.getDirection().
+ equalsIgnoreCase("out"));
+
+ fr = (FileRecord)it.next();
+ assertTrue("Filetransfers not found",
+ fr.getFile().getName().
+ equals(files[5].getName()));
+ assertTrue("Filetransfers status wrong",
+ fr.getStatus().
+ equals("completed"));
+ assertTrue("Filetransfers direction wrong",
+ fr.getDirection().
+ equalsIgnoreCase("in"));
+
+ rs = getFileRecords(
+ metaHistoryService.findByKeyword(
+ new String[]{FileHistoryService.class.getName()},
+ testMetaContact,
+ "t3"));
+ assertTrue("Filetransfers must be atleast 1", rs.size() > 0);
+
+ it = rs.iterator();
+ assertTrue("Filetransfers not found",
+ ((FileRecord)it.next()).getFile().getName().
+ equals(files[2].getName()));
+
+ rs = getFileRecords(
+ metaHistoryService.findByKeyword(
+ new String[]{FileHistoryService.class.getName()},
+ testMetaContact,
+ "T3", true));
+ assertEquals("Filetransfers must be 0", rs.size(), 0);
+
+ rs = getFileRecords(
+ metaHistoryService.findByKeywords(
+ new String[]{FileHistoryService.class.getName()},
+ testMetaContact,
+ new String[]{"t3"}));
+ assertTrue("Filetransfers must be atleast 1", rs.size() > 0);
+
+ it = rs.iterator();
+ assertTrue("Filetransfers not found",
+ ((FileRecord)it.next()).getFile().getName().
+ equals(files[2].getName()));
+
+ rs = getFileRecords(
+ metaHistoryService.findByKeywords(
+ new String[]{FileHistoryService.class.getName()},
+ testMetaContact,
+ new String[]{"T3"}, true));
+ assertEquals("Filetransfers must be 0", rs.size(), 0);
+
+ rs = getFileRecords(
+ metaHistoryService.findFirstMessagesAfter(
+ new String[]{FileHistoryService.class.getName()},
+ testMetaContact,
+ controlDate1,
+ 2));
+ assertEquals("Filetransfers must be 2", rs.size(), 2);
+
+ it = rs.iterator();
+ fr = (FileRecord)it.next();
+ assertTrue("Filetransfers not found",
+ fr.getFile().getName().
+ equals(files[2].getName()));
+ assertTrue("Filetransfers status wrong",
+ fr.getStatus().
+ equals("completed"));
+ assertTrue("Filetransfers direction wrong",
+ fr.getDirection().
+ equalsIgnoreCase("out"));
+
+ fr = (FileRecord)it.next();
+ assertTrue("Filetransfers not found",
+ fr.getFile().getName().
+ equals(files[3].getName()));
+ assertTrue("Filetransfers status wrong",
+ fr.getStatus().
+ equals("active"));
+ assertTrue("Filetransfers direction wrong",
+ fr.getDirection().
+ equalsIgnoreCase("in"));
+
+ rs = getFileRecords(
+ metaHistoryService.findLastMessagesBefore(
+ new String[]{FileHistoryService.class.getName()},
+ testMetaContact,
+ controlDate1,
+ 2));
+ assertEquals("Filetransfers must be 2", rs.size(), 2);
+
+ it = rs.iterator();
+ fr = (FileRecord)it.next();
+ assertTrue("Filetransfers not found",
+ fr.getFile().getName().
+ equals(files[0].getName()));
+ assertTrue("Filetransfers status wrong",
+ fr.getStatus().
+ equals("canceled"));
+ assertTrue("Filetransfers direction wrong",
+ fr.getDirection().
+ equalsIgnoreCase("out"));
+
+ fr = (FileRecord)it.next();
+ assertTrue("Filetransfers not found",
+ fr.getFile().getName().
+ equals(files[1].getName()));
+ assertTrue("Filetransfers status wrong",
+ fr.getStatus().
+ equals("completed"));
+ assertTrue("Filetransfers direction wrong",
+ fr.getDirection().
+ equalsIgnoreCase("in"));
+ }
+
+ public void metaTests()
+ {
+ Collection rs = metaHistoryService.findByStartDate(
+ new String[]{
+ MessageHistoryService.class.getName(),
+ FileHistoryService.class.getName(),
+ CallHistoryService.class.getName()},
+ testMetaContact, controlDate1);
+
+ assertEquals("Records must be 12", 12, rs.size());
+ assertEquals("Filetransfers must be 4", 4, getFileRecords(rs).size());
+ assertEquals("CallRecords must be 4", 4, getCalls(rs).size());
+ assertEquals("MessageRecords must be 4", 4, getMessages(rs).size());
+
+ rs = metaHistoryService.findByEndDate(
+ new String[]{
+ MessageHistoryService.class.getName(),
+ FileHistoryService.class.getName(),
+ CallHistoryService.class.getName()},
+ testMetaContact, controlDate1);
+
+ assertTrue("Records must be atleast", rs.size() >= 6);
+
+ rs = metaHistoryService.findByPeriod(
+ new String[]{
+ MessageHistoryService.class.getName(),
+ FileHistoryService.class.getName(),
+ CallHistoryService.class.getName()},
+ testMetaContact, controlDate1, controlDate2);
+ assertEquals("Records must be 6", 6, rs.size());
+ assertEquals("Filetransfers must be 2", 2, getFileRecords(rs).size());
+ assertEquals("CallRecords must be 2", 2, getCalls(rs).size());
+ assertEquals("MessageRecords must be 2", 2, getMessages(rs).size());
+
+ rs = metaHistoryService.findByPeriod(
+ new String[]{
+ MessageHistoryService.class.getName(),
+ FileHistoryService.class.getName(),
+ CallHistoryService.class.getName()},
+ testMetaContact, controlDate1, controlDate2,
+ new String[]{"t4", "participant_address_4", "word4"});
+ assertEquals("Records must be 1", 1, rs.size());
+ assertEquals("Filetransfers must be 0", 0, getFileRecords(rs).size());
+ assertEquals("CallRecords must be 0", 0, getCalls(rs).size());
+ assertEquals("MessageRecords must be 1", 1, getMessages(rs).size());
+
+ rs = metaHistoryService.findByPeriod(
+ new String[]{
+ MessageHistoryService.class.getName(),
+ FileHistoryService.class.getName(),
+ CallHistoryService.class.getName()},
+ testMetaContact, controlDate1, controlDate2,
+ new String[]{"T4", "participant_address_4", "word4"},
+ true);
+ assertEquals("Records must be 0", 0, rs.size());
+
+ rs = metaHistoryService.findByKeyword(
+ new String[]{
+ MessageHistoryService.class.getName(),
+ FileHistoryService.class.getName(),
+ CallHistoryService.class.getName()},
+ testMetaContact,
+ "T1");
+ assertTrue("Records must be atleast 2", rs.size() > 2);
+
+ rs = metaHistoryService.findByKeyword(
+ new String[]{
+ MessageHistoryService.class.getName(),
+ FileHistoryService.class.getName(),
+ CallHistoryService.class.getName()},
+ testMetaContact,
+ "Word6", true);
+ assertEquals("Records must be 0", 0, rs.size());
+
+ rs = metaHistoryService.findByKeywords(
+ new String[]{
+ MessageHistoryService.class.getName(),
+ FileHistoryService.class.getName(),
+ CallHistoryService.class.getName()},
+ testMetaContact,
+ new String[]{"t4", "participant_address_4", "word4"});
+ assertTrue("Records must be atleast 1", rs.size() > 1);
+
+ rs = metaHistoryService.findByKeywords(
+ new String[]{
+ MessageHistoryService.class.getName(),
+ FileHistoryService.class.getName(),
+ CallHistoryService.class.getName()},
+ testMetaContact,
+ new String[]{"T4", "participant_address_4", "word4"},
+ true);
+ assertEquals("Records must be 0", 0, rs.size());
+
+ rs = metaHistoryService.findLast(
+ new String[]{
+ MessageHistoryService.class.getName(),
+ FileHistoryService.class.getName(),
+ CallHistoryService.class.getName()},
+ testMetaContact,
+ 4);
+ assertEquals("Records must be 4", 4, rs.size());
+ assertEquals("Filetransfers must be 2", 2, getFileRecords(rs).size());
+ assertEquals("CallRecords must be 0", 0, getCalls(rs).size());
+ assertEquals("MessageRecords must be 2", 2, getMessages(rs).size());
+
+ rs = metaHistoryService.findFirstMessagesAfter(
+ new String[]{
+ MessageHistoryService.class.getName(),
+ FileHistoryService.class.getName(),
+ CallHistoryService.class.getName()},
+ testMetaContact,
+ controlDate1,
+ 2);
+ assertEquals("Records must be 2", 2, rs.size());
+ assertEquals("Filetransfers must be 0", 0, getFileRecords(rs).size());
+ assertEquals("CallRecords must be 2", 2, getCalls(rs).size());
+ assertEquals("MessageRecords must be 0", 0, getMessages(rs).size());
+
+ rs = metaHistoryService.findLastMessagesBefore(
+ new String[]{
+ MessageHistoryService.class.getName(),
+ FileHistoryService.class.getName(),
+ CallHistoryService.class.getName()},
+ testMetaContact,
+ controlDate1,
+ 2);
+ assertEquals("Records must be 2", 2, rs.size());
+ assertEquals("Filetransfers must be 0", 0, getFileRecords(rs).size());
+ assertEquals("CallRecords must be 0", 0, getCalls(rs).size());
+ assertEquals("MessageRecords must be 2", 2, getMessages(rs).size());
+ }
+
+ /**
+ * Removes the locally stored contact list copy. The purpose of this is to
+ * leave the local list empty for a next round of testing.
+ */
+ public void testPurgeLocalContactListCopy()
+ {
+ metaClService.purgeLocallyStoredContactListCopy();
+ }
+
+ private Vector getMessages(Collection rs)
+ {
+ Vector result = new Vector();
+ Iterator iter = rs.iterator();
+ while (iter.hasNext())
+ {
+ Object item = iter.next();
+ if(item instanceof MessageDeliveredEvent)
+ result.add(((MessageDeliveredEvent)item).getSourceMessage().getContent());
+ else
+ if(item instanceof MessageReceivedEvent)
+ result.add(((MessageReceivedEvent)item).getSourceMessage().getContent());
+ }
+
+ return result;
+ }
+
+ private Vector getCalls(Collection rs)
+ {
+ Vector result = new Vector();
+ Iterator iter = rs.iterator();
+ while (iter.hasNext())
+ {
+ Object item = iter.next();
+ if(item instanceof CallRecord)
+ result.add(item);
+ }
+
+ return result;
+ }
+
+ private Collection getFileRecords(Collection rs)
+ {
+ Vector result = new Vector();
+ Iterator iter = rs.iterator();
+ while (iter.hasNext())
+ {
+ Object item = iter.next();
+ if(item instanceof FileRecord)
+ result.add(item);
+ }
+
+ return result;
+ }
+
+ private class TransferListener
+ implements FileTransferListener
+ {
+ String fileName = null;
+ boolean accept = true;
+ boolean finishTransfer = true;
+ TransferListener(String fileName, boolean accept, boolean finishTransfer)
+ {
+ this.fileName = fileName;
+ this.accept = accept;
+ this.finishTransfer = finishTransfer;
+ }
+
+ public void fileTransferRequestReceived(FileTransferRequestEvent event)
+ {
+ if(accept)
+ {
+ FileTransfer ft = event.getRequest().acceptFile(new File(fileName));
+ if(finishTransfer)
+ {
+ mockFTOpSet.changeFileTransferStatus(
+ ft, FileTransferStatusChangeEvent.COMPLETED);
+ }
+ else
+ {
+ mockFTOpSet.changeFileTransferStatus(
+ ft, FileTransferStatusChangeEvent.CANCELED);
+ }
+ }
+ else
+ event.getRequest().rejectFile();
+ }
+
+ public void fileTransferCreated(FileTransferCreatedEvent event)
+ {
+
+ }
+
+ }
+}
diff --git a/test/net/java/sip/communicator/slick/msghistory/metahistory.slick.manifest.mf b/test/net/java/sip/communicator/slick/msghistory/metahistory.slick.manifest.mf
new file mode 100644
index 000000000..222375749
--- /dev/null
+++ b/test/net/java/sip/communicator/slick/msghistory/metahistory.slick.manifest.mf
@@ -0,0 +1,26 @@
+Bundle-Activator: net.java.sip.communicator.slick.metahistory.MetaHistoryServiceLick
+Bundle-Name: Meta History Service Implementation Compatibility Kit
+Bundle-Description: A Service Implementation Compatibility Kit for the File History Service
+Bundle-Vendor: sip-communicator.org
+Bundle-Version: 0.0.1
+System-Bundle: yes
+Import-Package: junit.framework,
+ net.java.sip.communicator.slick.history,
+ net.java.sip.communicator.service.history.records,
+ net.java.sip.communicator.service.history,
+ net.java.sip.communicator.service.filehistory,
+ net.java.sip.communicator.service.callhistory,
+ net.java.sip.communicator.service.msghistory,
+ net.java.sip.communicator.service.contactlist,
+ net.java.sip.communicator.service.metahistory,
+ net.java.sip.communicator.impl.protocol.mock,
+ net.java.sip.communicator.service.protocol,
+ net.java.sip.communicator.service.protocol.event,
+ org.osgi.framework,
+ org.w3c.dom,
+ javax.xml.parsers,
+ net.java.sip.communicator.util,
+ net.java.sip.communicator.util.xml,
+ javax.xml.transform,
+ javax.xml.transform.dom,
+ javax.xml.transform.stream