Merge pull request #148 from ShaneMcC/TimestampProcessors

Make all IRCProcessors handle timestamps.

irc/src/main/java/com/dmdirc/parser/irc/IRCParser.java

                         case IrcConstants.NUMERIC_ERROR_PASSWORD_MISMATCH:
                         case IrcConstants.NUMERIC_ERROR_NICKNAME_IN_USE:
                             try {
-                                myProcessingManager.process(sParam, token);
+                                myProcessingManager.process(lineTS, sParam, token);
                             } catch (ProcessorNotFoundException e) {
                             }
                             break;

irc/src/main/java/com/dmdirc/parser/irc/ProcessingManager.java

         }
     }
 
-    /**
-     * Process a Line.
-     *
-     * @param sParam Type of line to process ("005", "PRIVMSG" etc)
-     * @param token IRCTokenised line to process
-     * @throws ProcessorNotFoundException exception if no processors exists to handle the line
-     */
-    public void process(final String sParam, final String... token) throws ProcessorNotFoundException {
-        process(LocalDateTime.now(), sParam, token);
-    }
-
     /**
      * Process a Line.
      *
         IRCProcessor messageProcessor = null;
         try {
             messageProcessor = getProcessor(sParam);
-            if (messageProcessor instanceof TimestampedIRCProcessor) {
-                ((TimestampedIRCProcessor)messageProcessor).process(date, sParam, token);
-            } else {
-                messageProcessor.process(sParam, token);
-            }
+            messageProcessor.process(date, sParam, token);
         } catch (ProcessorNotFoundException p) {
             throw p;
         } catch (Exception e) {
             parser.callErrorInfo(ei);
         } finally {
             // Try to call callNumeric. We don't want this to work if sParam is a non
-            // integer param, hense the empty catch
+            // integer param, hence the empty catch
             try {
-                callNumeric(Integer.parseInt(sParam), token);
+                callNumeric(date, Integer.parseInt(sParam), token);
             } catch (NumberFormatException e) {
             }
         }
      * @param numeric What numeric is this for
      * @param token IRC Tokenised line
      */
-    protected void callNumeric(final int numeric, final String... token) {
-        parser.getCallbackManager().publish(new NumericEvent(parser, LocalDateTime.now(), numeric,
+    protected void callNumeric(final LocalDateTime time, final int numeric, final String... token) {
+        parser.getCallbackManager().publish(new NumericEvent(parser, time, numeric,
                 token));
     }
 }

irc/src/main/java/com/dmdirc/parser/irc/TimestampedIRCProcessor.java

-/*
- * Copyright (c) 2006-2017 DMDirc Developers
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package com.dmdirc.parser.irc;
-
-import com.dmdirc.parser.irc.processors.IRCProcessor;
-
-import java.time.LocalDateTime;
-
-/**
- * TimestampedIRCProcessor.
- *
- * Superclass for all IRCProcessor types that accept timestamps for process.
- */
-public abstract class TimestampedIRCProcessor extends IRCProcessor {
-
-    /**
-     * Create a new instance of the IRCTimestampedProcessor Object.
-     *
-     * @param parser IRCParser That owns this IRCProcessor
-     * @param handledTokens Tokens that this processor handles
-     */
-    protected TimestampedIRCProcessor(final IRCParser parser, final String... handledTokens) {
-        super(parser, handledTokens);
-    }
-
-    @Override
-    public final void process(final String sParam, final String... token) {
-        process(LocalDateTime.now(), sParam, token);
-    }
-
-    /**
-     * Process a Line.
-     *
-     * @param date Date of this line
-     * @param sParam Type of line to process ("005", "PRIVMSG" etc)
-     * @param token IRCTokenised line to process
-     */
-    public abstract void process(final LocalDateTime date, final String sParam,
-            final String... token);
-
-
-}

irc/src/main/java/com/dmdirc/parser/irc/processors/IRCProcessor.java

 import com.dmdirc.parser.irc.IRCClientInfo;
 import com.dmdirc.parser.irc.IRCParser;
 
+import java.time.LocalDateTime;
+
 /**
  * IRCProcessor.
  * Superclass for all IRCProcessor types.
     /**
      * Process a Line.
      *
+     * @param date Date of this line
      * @param sParam Type of line to process ("005", "PRIVMSG" etc)
      * @param token IRCTokenised line to process
      */
-    public abstract void process(final String sParam, final String... token);
+    public abstract void process(final LocalDateTime date, final String sParam, final String... token);
 
     /**
      * What does this IRCProcessor handle.

irc/src/main/java/com/dmdirc/parser/irc/processors/Process001.java

 import com.dmdirc.parser.common.ParserError;
 import com.dmdirc.parser.irc.IRCParser;
 
+import java.time.LocalDateTime;
 import java.util.Collection;
 
 import javax.inject.Inject;
      * @param token IRCTokenised line to process
      */
     @Override
-    public void process(final String sParam, final String... token) {
+    public void process(final LocalDateTime time, final String sParam, final String... token) {
         parser.got001 = true;
         // << :demon1.uk.quakenet.org 001 Java-Test :Welcome to the QuakeNet IRC Network, Java-Test
         parser.updateServerName(token[0].substring(1, token[0].length()));

irc/src/main/java/com/dmdirc/parser/irc/processors/Process004005.java

      * @param token IRCTokenised line to process
      */
     @Override
-    public void process(final String sParam, final String... token) {
+    public void process(final LocalDateTime time, final String sParam, final String... token) {
         switch (sParam) {
             case "002":
                 process002();

irc/src/main/java/com/dmdirc/parser/irc/processors/Process464.java

      * @param token IRCTokenised line to process
      */
     @Override
-    public void process(final String sParam, final String... token) {
-        callPasswordRequired();
+    public void process(final LocalDateTime time, final String sParam, final String... token) {
+        callPasswordRequired(time);
     }
 
     /**
      * Callback to all objects implementing the PasswordRequired Callback.
      */
-    protected void callPasswordRequired() {
-        getCallbackManager().publish(new PasswordRequiredEvent(parser, LocalDateTime.now()));
+    protected void callPasswordRequired(final LocalDateTime time) {
+        getCallbackManager().publish(new PasswordRequiredEvent(parser, time));
     }
 }

irc/src/main/java/com/dmdirc/parser/irc/processors/ProcessAccount.java

 import com.dmdirc.parser.irc.IRCClientInfo;
 import com.dmdirc.parser.irc.IRCParser;
 
+import java.time.LocalDateTime;
+
 import javax.inject.Inject;
 
 /**
      * @param token IRCTokenised line to process
      */
     @Override
-    public void process(final String sParam, final String... token) {
+    public void process(final LocalDateTime time, final String sParam, final String... token) {
         // :nick!user@host ACCOUNT accountname
         final IRCClientInfo iClient = getClientInfo(token[0]);
         if (iClient != null) {

irc/src/main/java/com/dmdirc/parser/irc/processors/ProcessAway.java

      * @param token IRCTokenised line to process
      */
     @Override
-    public void process(final String sParam, final String... token) {
+    public void process(final LocalDateTime time, final String sParam, final String... token) {
         final IRCClientInfo iClient = getClientInfo(token[0]);
         switch (sParam) {
             case "AWAY":
                     iClient.setAwayState(reason.isEmpty() ? AwayState.HERE : AwayState.AWAY);
 
                     if (iClient == parser.getLocalClient()) {
-                        callAwayState(oldState, iClient.getAwayState(), iClient.getAwayReason());
+                        callAwayState(time, oldState, iClient.getAwayState(), iClient.getAwayReason());
                     }
                 }
                 break;
                 // IRC HERE/BACK response
                 final AwayState oldState = parser.getLocalClient().getAwayState();
                 parser.getLocalClient().setAwayState("306".equals(sParam) ? AwayState.AWAY : AwayState.HERE);
-                callAwayState(oldState, parser.getLocalClient().getAwayState(), parser.getLocalClient().getAwayReason());
+                callAwayState(time, oldState, parser.getLocalClient().getAwayState(), parser.getLocalClient().getAwayReason());
                 break;
         }
     }
      * @param currentState Current Away State
      * @param reason Best guess at away reason
      */
-    protected void callAwayState(final AwayState oldState, final AwayState currentState,
+    protected void callAwayState(final LocalDateTime time, final AwayState oldState, final AwayState currentState,
             final String reason) {
         getCallbackManager().publish(
-                new AwayStateEvent(parser, LocalDateTime.now(), oldState, currentState, reason));
+                new AwayStateEvent(parser, time, oldState, currentState, reason));
     }
 
 }

irc/src/main/java/com/dmdirc/parser/irc/processors/ProcessCap.java

 
 import com.dmdirc.parser.irc.CapabilityState;
 import com.dmdirc.parser.irc.IRCParser;
-import com.dmdirc.parser.irc.TimestampedIRCProcessor;
 
 import java.time.LocalDateTime;
 import java.util.ArrayList;
  * See: http://www.leeh.co.uk/draft-mitchell-irc-capabilities-02.html
  * See: http://ircv3.atheme.org/specification/capability-negotiation-3.1
  */
-public class ProcessCap extends TimestampedIRCProcessor {
+public class ProcessCap extends IRCProcessor {
     /** Have we handled the pre-connect cap request? */
     private boolean hasCapped;
     /** List of supported capabilities. */

irc/src/main/java/com/dmdirc/parser/irc/processors/ProcessInvite.java

      * @param token IRCTokenised line to process
      */
     @Override
-    public void process(final String sParam, final String... token) {
+    public void process(final LocalDateTime time, final String sParam, final String... token) {
         // :Tobavaj!shane@Tobavaj.users.quakenet.org INVITE Dataforce #dataforceisgod 1188846462
         if (token.length > 2) {
-            callInvite(token[0].substring(1), token[3]);
+            callInvite(time, token[0].substring(1), token[3]);
         }
     }
 
      * @param userHost The hostname of the person who invited us
      * @param channel The name of the channel we were invited to
      */
-    protected void callInvite(final String userHost, final String channel) {
+    protected void callInvite(final LocalDateTime time, final String userHost, final String channel) {
         getCallbackManager().publish(new InviteEvent(
-                parser, LocalDateTime.now(), userHost, channel));
+                parser, time, userHost, channel));
     }
 
 }

irc/src/main/java/com/dmdirc/parser/irc/processors/ProcessJoin.java

     /**
      * Process a channel join.
      *
+     * @param date The LocalDateTime that this event occurred at.
      * @param sParam Type of line to process ("JOIN")
      * @param token IRCTokenised line to process
      */
     @Override
-    public void process(final String sParam, final String... token) {
+    public void process(final LocalDateTime date, final String sParam, final String... token) {
         callDebugInfo(IRCParser.DEBUG_INFO, "processJoin: %s | %s", sParam, Arrays.toString(token));
 
         if ("329".equals(sParam)) {
                         } else {
                             // If we are joining a channel we are already on, fake a part from
                             // the channel internally, and rejoin.
-                            parser.getProcessingManager().process("PART", token);
+                            parser.getProcessingManager().process(date, "PART", token);
                         }
                     } catch (ProcessorNotFoundException e) {
                     }
                     // joined.
                     callDebugInfo(IRCParser.DEBUG_INFO, "processJoin: Adding client to channel.");
                     final IRCChannelClientInfo iChannelClient = iChannel.addClient(iClient);
-                    callChannelJoin(iChannel, iChannelClient);
+                    callChannelJoin(date, iChannel, iChannelClient);
                     callDebugInfo(IRCParser.DEBUG_INFO, "processJoin: Added client to channel.");
                     return;
                 } else {
                 pendingJoins.clear();
             }
 
-            callChannelSelfJoin(iChannel);
+            callChannelSelfJoin(date, iChannel);
         } else {
             // Some kind of failed to join, pop the pending join queues.
             final PendingJoin pendingJoin = pendingJoins.poll();
     /**
      * Callback to all objects implementing the ChannelJoin Callback.
      *
+     * @param date The LocalDateTime that this event occurred at.
      * @param cChannel Channel Object
      * @param cChannelClient ChannelClient object for new person
      */
-    protected void callChannelJoin(final ChannelInfo cChannel,
+    protected void callChannelJoin(final LocalDateTime date, final ChannelInfo cChannel,
             final ChannelClientInfo cChannelClient) {
         getCallbackManager().publish(
-                new ChannelJoinEvent(parser, LocalDateTime.now(), cChannel, cChannelClient));
+                new ChannelJoinEvent(parser, date, cChannel, cChannelClient));
     }
 
     /**
      * Callback to all objects implementing the ChannelSelfJoin Callback.
      *
+     * @param date The LocalDateTime that this event occurred at.
      * @param cChannel Channel Object
      */
-    protected void callChannelSelfJoin(final ChannelInfo cChannel) {
+    protected void callChannelSelfJoin(final LocalDateTime date, final ChannelInfo cChannel) {
         getCallbackManager().publish(new ChannelSelfJoinEvent(
-                parser, LocalDateTime.now(), cChannel));
+                parser, date, cChannel));
     }
 
 

irc/src/main/java/com/dmdirc/parser/irc/processors/ProcessKick.java

     /**
      * Process a channel kick.
      *
+     * @param date The LocalDateTime that this event occurred at.
      * @param sParam Type of line to process ("KICK")
      * @param token IRCTokenised line to process
      */
     @Override
-    public void process(final String sParam, final String... token) {
+    public void process(final LocalDateTime date, final String sParam, final String... token) {
         callDebugInfo(IRCParser.DEBUG_INFO, "processKick: %s | %s", sParam, Arrays.toString(token));
 
         final IRCClientInfo iClient = getClientInfo(token[3]);
             final IRCChannelClientInfo iChannelKicker = iChannel.getChannelClient(token[0], true);
             if (parser.getRemoveAfterCallback()) {
                 callDebugInfo(IRCParser.DEBUG_INFO, "processKick: calling kick before. {%s | %s | %s | %s | %s}", iChannel, iChannelClient, iChannelKicker, sReason, token[0]);
-                callChannelKick(iChannel, iChannelClient, iChannelKicker, sReason, token[0]);
+                callChannelKick(date, iChannel, iChannelClient, iChannelKicker, sReason, token[0]);
             }
             callDebugInfo(IRCParser.DEBUG_INFO, "processKick: removing client from channel { %s | %s }", iChannel, iClient);
             iChannel.delClient(iClient);
             callDebugInfo(IRCParser.DEBUG_INFO, "processKick: removed client from channel { %s | %s }", iChannel, iClient);
             if (!parser.getRemoveAfterCallback()) {
                 callDebugInfo(IRCParser.DEBUG_INFO, "processKick: calling kick after. {%s | %s | %s | %s | %s}", iChannel, iChannelClient, iChannelKicker, sReason, token[0]);
-                callChannelKick(iChannel, iChannelClient, iChannelKicker, sReason, token[0]);
+                callChannelKick(date, iChannel, iChannelClient, iChannelKicker, sReason, token[0]);
             }
             if (iClient == parser.getLocalClient()) {
                 iChannel.emptyChannel();
     /**
      * Callback to all objects implementing the ChannelKick Callback.
      *
+     * @param date The LocalDateTime that this event occurred at.
      * @param cChannel Channel where the kick took place
      * @param cKickedClient ChannelClient that got kicked
      * @param cKickedByClient ChannelClient that did the kicking
      * @param sReason Reason for kick (may be "")
      * @param sKickedByHost Hostname of Kicker (or servername)
      */
-    protected void callChannelKick(final ChannelInfo cChannel,
+    protected void callChannelKick(final LocalDateTime date, final ChannelInfo cChannel,
             final ChannelClientInfo cKickedClient, final ChannelClientInfo cKickedByClient,
             final String sReason, final String sKickedByHost) {
         getCallbackManager().publish(
-                new ChannelKickEvent(parser, LocalDateTime.now(), cChannel, cKickedClient,
+                new ChannelKickEvent(parser, date, cChannel, cKickedClient,
                         cKickedByClient, sReason, sKickedByHost));
     }
 

irc/src/main/java/com/dmdirc/parser/irc/processors/ProcessList.java

      * @param token IRCTokenised line to process
      */
     @Override
-    public void process(final String sParam, final String... token) {
+    public void process(final LocalDateTime time, final String sParam, final String... token) {
         // :port80b.se.quakenet.org 321 MD87 Channel :Users  Name
         // :port80b.se.quakenet.org 322 MD87 #DMDirc 10 :
         // :port80b.se.quakenet.org 323 MD87 :End of /LIST
         switch (sParam) {
             case "321":
-                getCallbackManager().publish(new GroupListStartEvent(parser, LocalDateTime.now()));
+                getCallbackManager().publish(new GroupListStartEvent(parser, time));
                 break;
             case "322":
-                getCallbackManager().publish(new GroupListEntryEvent(parser, LocalDateTime.now(),
+                getCallbackManager().publish(new GroupListEntryEvent(parser, time,
                         token[3], Integer.parseInt(token[4]), token[5]));
                 break;
             case "323":
-                getCallbackManager().publish(new GroupListEndEvent(parser, LocalDateTime.now()));
+                getCallbackManager().publish(new GroupListEndEvent(parser, time));
                 break;
         }
     }

irc/src/main/java/com/dmdirc/parser/irc/processors/ProcessListModes.java

     /**
      * Process a ListModes.
      *
+     * @param date The LocalDateTime that this event occurred at.
      * @param sParam Type of line to process
      * @param token IRCTokenised line to process
      */
     @Override
-    public void process(final String sParam, final String... token) {
+    public void process(final LocalDateTime date, final String sParam, final String... token) {
         final IRCChannelInfo channel = getChannel(token[3]);
         final ServerType serverType = parser.getServerType();
         if (channel == null) {
                             .stream()
                             .filter(thisMode -> parser.chanModesOther
                                     .get(thisMode) == IRCParser.MODE_LIST)
-                            .forEach(thisMode -> callChannelGotListModes(channel, thisMode));
+                            .forEach(thisMode -> callChannelGotListModes(date, channel, thisMode));
                 } else {
-                    callChannelGotListModes(channel, mode);
+                    callChannelGotListModes(date, channel, mode);
                 }
             }
         }
     /**
      * Callback to all objects implementing the ChannelGotListModes Callback.
      *
+     * @param date The LocalDateTime that this event occurred at.
      * @param cChannel Channel which the ListModes reply is for
      * @param mode the mode that we got list modes for.
      */
-    protected void callChannelGotListModes(final ChannelInfo cChannel, final char mode) {
-        getCallbackManager().publish(new ChannelListModeEvent(parser, LocalDateTime.now(), cChannel,
+    protected void callChannelGotListModes(final LocalDateTime date, final ChannelInfo cChannel, final char mode) {
+        getCallbackManager().publish(new ChannelListModeEvent(parser, date, cChannel,
                 mode));
     }
 }

irc/src/main/java/com/dmdirc/parser/irc/processors/ProcessMOTD.java

      * @param token IRCTokenised line to process
      */
     @Override
-    public void process(final String sParam, final String... token) {
+    public void process(final LocalDateTime time, final String sParam, final String... token) {
         switch (sParam) {
             case "375":
-                callMOTDStart(token[token.length - 1]);
+                callMOTDStart(time, token[token.length - 1]);
                 break;
             case "372":
-                callMOTDLine(token[token.length - 1]);
+                callMOTDLine(time, token[token.length - 1]);
                 break;
             default:
-                callMOTDEnd("422".equals(sParam), token[token.length - 1]);
+                callMOTDEnd(time, "422".equals(sParam), token[token.length - 1]);
                 break;
         }
     }
      * @param noMOTD Was this an MOTDEnd or NoMOTD
      * @param data The contents of the line (incase of language changes or so)
      */
-    protected void callMOTDEnd(final boolean noMOTD, final String data) {
-        getCallbackManager().publish(new MOTDEndEvent(parser, LocalDateTime.now(), noMOTD, data));
+    protected void callMOTDEnd(final LocalDateTime time, final boolean noMOTD, final String data) {
+        getCallbackManager().publish(new MOTDEndEvent(parser, time, noMOTD, data));
     }
 
     /**
      *
      * @param data Incomming Line.
      */
-    protected void callMOTDLine(final String data) {
-        getCallbackManager().publish(new MOTDLineEvent(parser, LocalDateTime.now(), data));
+    protected void callMOTDLine(final LocalDateTime time, final String data) {
+        getCallbackManager().publish(new MOTDLineEvent(parser, time, data));
     }
 
     /**
      *
      * @param data Incomming Line.
      */
-    protected void callMOTDStart(final String data) {
-        getCallbackManager().publish(new MOTDStartEvent(parser, LocalDateTime.now(), data));
+    protected void callMOTDStart(final LocalDateTime time, final String data) {
+        getCallbackManager().publish(new MOTDStartEvent(parser, time, data));
     }
 
 }

irc/src/main/java/com/dmdirc/parser/irc/processors/ProcessMessage.java

 import com.dmdirc.parser.irc.IRCParser;
 import com.dmdirc.parser.irc.PrefixModeManager;
 import com.dmdirc.parser.irc.ProcessorNotFoundException;
-import com.dmdirc.parser.irc.TimestampedIRCProcessor;
 
 import java.time.LocalDateTime;
 import java.util.regex.PatternSyntaxException;
  * Actions are handled here aswell separately from CTCPs.<br>
  * Each type has 5 Calls, making 15 callbacks handled here.
  */
-public class ProcessMessage extends TimestampedIRCProcessor {
+public class ProcessMessage extends IRCProcessor {
 
     /** The manager to use to access prefix modes. */
     private final PrefixModeManager prefixModeManager;
      * Actions are handled here aswell separately from CTCPs.<br>
      * Each type has 5 Calls, making 15 callbacks handled here.
      *
+     * @param date The LocalDateTime that this event occurred at.
      * @param sParam Type of line to process ("NOTICE", "PRIVMSG")
      * @param token IRCTokenised line to process
      */

irc/src/main/java/com/dmdirc/parser/irc/processors/ProcessMode.java

     /**
      * Process a Mode Line.
      *
+     * @param date The LocalDateTime that this event occurred at.
      * @param sParam Type of line to process ("MODE", "324")
      * @param token IRCTokenised line to process
      */
     @Override
-    public void process(final String sParam, final String... token) {
+    public void process(final LocalDateTime date, final String sParam, final String... token) {
         final String[] sModestr;
         final String sChannelName;
         switch (sParam) {
                 System.arraycopy(token, 4, sModestr, 0, token.length - 4);
                 break;
             case "221":
-                processUserMode(sParam, token, new String[]{token[token.length - 1]}, true);
+                processUserMode(date, sParam, token, new String[]{token[token.length - 1]}, true);
                 return;
             default:
                 sChannelName = token[2];
         }
 
         if (isValidChannelName(sChannelName)) {
-            processChanMode(sParam, token, sModestr, sChannelName);
+            processChanMode(date, sParam, token, sModestr, sChannelName);
         } else {
-            processUserMode(sParam, token, sModestr, false);
+            processUserMode(date, sParam, token, sModestr, false);
         }
     }
 
     /**
      * Process Chan modes.
      *
+     * @param date The LocalDateTime that this event occurred at.
      * @param sParam String representation of parameter to parse
      * @param token IRCTokenised Array of the incomming line
      * @param sModestr The modes and params
      * @param sChannelName Channel these modes are for
      */
-    public void processChanMode(final String sParam, final String[] token, final String[] sModestr, final String sChannelName) {
+    public void processChanMode(final LocalDateTime date, final String sParam, final String[] token, final String[] sModestr, final String sChannelName) {
         final StringBuilder sFullModeStr = new StringBuilder();
 
         final IRCChannelInfo iChannel = getChannel(sChannelName);
                     } else {
                         iChannelClientInfo.removeMode(cMode);
                     }
-                    callChannelUserModeChanged(iChannel, iChannelClientInfo, setterCCI, token[0],
+                    callChannelUserModeChanged(date, iChannel, iChannelClientInfo, setterCCI, token[0],
                             (bPositive ? "+" : "-") + cMode);
                     continue;
                 } else {
                         if (!"324".equals(sParam)) {
                             getCallbackManager().publish(
                                     new ChannelSingleModeChangeEvent(
-                                            parser, LocalDateTime.now(), iChannel,
+                                            parser, date, iChannel,
                                             setterCCI, token[0], cPositive + cMode + " " +
                                             sModeParam));
                         }
                             if (!"324".equals(sParam)) {
                                 getCallbackManager().publish(
                                         new ChannelSingleModeChangeEvent(
-                                                parser, LocalDateTime.now(),
+                                                parser, date,
                                                 iChannel, setterCCI, token[0],
                                                 cPositive + cMode + " " +
                                                         sModeParam));
                             if (!"324".equals(sParam)) {
                                 getCallbackManager().publish(
                                         new ChannelSingleModeChangeEvent(
-                                                parser, LocalDateTime.now(),
+                                                parser, date,
                                                 iChannel, setterCCI, token[0],
                                                 trim(cPositive + cMode + " " + sModeParam)));
                             }
 
         iChannel.setMode(nCurrent);
         if ("324".equals(sParam)) {
-            callChannelModeChanged(iChannel, setterCCI, "", sFullModeStr.toString().trim());
+            callChannelModeChanged(date, iChannel, setterCCI, "", sFullModeStr.toString().trim());
         } else {
-            callChannelModeChanged(iChannel, setterCCI, token[0], sFullModeStr.toString().trim());
+            callChannelModeChanged(date, iChannel, setterCCI, token[0], sFullModeStr.toString().trim());
             getCallbackManager().publish(
-                    new ChannelNonUserModeChangeEvent(parser, LocalDateTime.now(), iChannel,
+                    new ChannelNonUserModeChangeEvent(parser, date, iChannel,
                             setterCCI, token[0],
                             trim(sNonUserModeStr.toString() + sNonUserModeStrParams)));
         }
     /**
      * Process user modes.
      *
+     * @param date The LocalDateTime that this event occurred at.
      * @param sParam String representation of parameter to parse
      * @param token IRCTokenised Array of the incomming line
      * @param clearOldModes Clear old modes before applying these modes (used by 221)
      */
-    private void processUserMode(final String sParam, final String[] token, final String[] sModestr,
+    private void processUserMode(final LocalDateTime date, final String sParam, final String[] token, final String[] sModestr,
             final boolean clearOldModes) {
         final IRCClientInfo iClient = getClientInfo(token[2]);
 
 
         iClient.setUserMode(nCurrent);
         if ("221".equals(sParam)) {
-            callUserModeDiscovered(iClient, sModestr[0]);
+            callUserModeDiscovered(date, iClient, sModestr[0]);
         } else {
-            callUserModeChanged(iClient, token[0], sModestr[0]);
+            callUserModeChanged(date, iClient, token[0], sModestr[0]);
         }
     }
 
     /**
      * Callback to all objects implementing the ChannelModeChanged Callback.
      *
+     * @param date The LocalDateTime that this event occurred at.
      * @param cChannel Channel where modes were changed
      * @param cChannelClient Client chaning the modes (null if server)
      * @param sHost Host doing the mode changing (User host or server name)
      * @param sModes Exact String parsed
      */
-    protected void callChannelModeChanged(final ChannelInfo cChannel,
+    protected void callChannelModeChanged(final LocalDateTime date, final ChannelInfo cChannel,
             final ChannelClientInfo cChannelClient, final String sHost, final String sModes) {
         getCallbackManager().publish(
-                new ChannelModeChangeEvent(parser, LocalDateTime.now(), cChannel, cChannelClient,
+                new ChannelModeChangeEvent(parser, date, cChannel, cChannelClient,
                         sHost, sModes));
     }
 
     /**
      * Callback to all objects implementing the ChannelUserModeChanged Callback.
      *
+     * @param date The LocalDateTime that this event occurred at.
      * @param cChannel Channel where modes were changed
      * @param cChangedClient Client being changed
      * @param cSetByClient Client chaning the modes (null if server)
      * @param sHost Host doing the mode changing (User host or server name)
      * @param sMode String representing mode change (ie +o)
      */
-    protected void callChannelUserModeChanged(final ChannelInfo cChannel,
+    protected void callChannelUserModeChanged(final LocalDateTime date, final ChannelInfo cChannel,
             final ChannelClientInfo cChangedClient, final ChannelClientInfo cSetByClient,
             final String sHost, final String sMode) {
         getCallbackManager().publish(
-                new ChannelUserModeChangeEvent(parser, LocalDateTime.now(), cChannel,
+                new ChannelUserModeChangeEvent(parser, date, cChannel,
                         cChangedClient, cSetByClient, sHost, sMode));
     }
 
     /**
      * Callback to all objects implementing the UserModeChanged Callback.
      *
+     * @param date The LocalDateTime that this event occurred at.
      * @param cClient Client that had the mode changed (almost always us)
      * @param sSetby Host that set the mode (us or servername)
      * @param sModes The modes set.
      */
-    protected void callUserModeChanged(final ClientInfo cClient, final String sSetby,
+    protected void callUserModeChanged(final LocalDateTime date, final ClientInfo cClient, final String sSetby,
             final String sModes) {
         getCallbackManager().publish(
-                new UserModeChangeEvent(parser, LocalDateTime.now(), cClient, sSetby, sModes));
+                new UserModeChangeEvent(parser, date, cClient, sSetby, sModes));
     }
 
     /**
      * Callback to all objects implementing the UserModeDiscovered Callback.
      *
+     * @param date The LocalDateTime that this event occurred at.
      * @param cClient Client that had the mode changed (almost always us)
      * @param sModes The modes set.
      */
-    protected void callUserModeDiscovered(final ClientInfo cClient, final String sModes) {
+    protected void callUserModeDiscovered(final LocalDateTime date, final ClientInfo cClient, final String sModes) {
         getCallbackManager().publish(
-                new UserModeDiscoveryEvent(parser, LocalDateTime.now(), cClient, sModes));
+                new UserModeDiscoveryEvent(parser, date, cClient, sModes));
     }
 
 }

irc/src/main/java/com/dmdirc/parser/irc/processors/ProcessNames.java

      * @param token IRCTokenised line to process
      */
     @Override
-    public void process(final String sParam, final String... token) {
+    public void process(final LocalDateTime time, final String sParam, final String... token) {
         final IRCChannelInfo iChannel;
         if ("366".equals(sParam)) {
             // End of names
             }
 
             if (!iChannel.hadTopic()) {
-                callChannelTopic(iChannel, true);
+                callChannelTopic(time, iChannel, true);
             }
 
             iChannel.setAddingNames(false);
-            callChannelGotNames(iChannel);
+            callChannelGotNames(time, iChannel);
 
             if (!iChannel.hasAskedForListModes()
                     && parser.getAutoListMode()) {
      * @param cChannel Channel that topic was set on
      * @param bIsJoinTopic True when getting topic on join, false if set by user/server
      */
-    protected void callChannelTopic(final ChannelInfo cChannel, final boolean bIsJoinTopic) {
+    protected void callChannelTopic(final LocalDateTime time, final ChannelInfo cChannel, final boolean bIsJoinTopic) {
         ((IRCChannelInfo) cChannel).setHadTopic();
         getCallbackManager().publish(
-                new ChannelTopicEvent(parser, LocalDateTime.now(), cChannel, bIsJoinTopic));
+                new ChannelTopicEvent(parser, time, cChannel, bIsJoinTopic));
     }
 
     /**
      *
      * @param cChannel Channel which the names reply is for
      */
-    protected void callChannelGotNames(final ChannelInfo cChannel) {
-        getCallbackManager().publish(new ChannelNamesEvent(parser, LocalDateTime.now(), cChannel));
+    protected void callChannelGotNames(final LocalDateTime time, final ChannelInfo cChannel) {
+        getCallbackManager().publish(new ChannelNamesEvent(parser, time, cChannel));
     }
 
 }

irc/src/main/java/com/dmdirc/parser/irc/processors/ProcessNick.java

     /**
      * Process a Nick change.
      *
+     * @param date The LocalDateTime that this event occurred at.
      * @param sParam Type of line to process ("NICK")
      * @param token IRCTokenised line to process
      */
     @Override
-    public void process(final String sParam, final String... token) {
+    public void process(final LocalDateTime date, final String sParam, final String... token) {
 
         final IRCClientInfo iClient = getClientInfo(token[0]);
         if (iClient == null) {
                     if (!isSameNick) {
                         iChannel.renameClient(oldNickname, iChannelClient);
                     }
-                    callChannelNickChanged(iChannel, iChannelClient, IRCClientInfo.parseHost(token[0]));
+                    callChannelNickChanged(date, iChannel, iChannelClient, IRCClientInfo.parseHost(token[0]));
                 }
             }
 
-            callNickChanged(iClient, IRCClientInfo.parseHost(token[0]));
+            callNickChanged(date, iClient, IRCClientInfo.parseHost(token[0]));
         }
     }
 
     /**
      * Callback to all objects implementing the ChannelNickChanged Callback.
      *
+     * @param date The LocalDateTime that this event occurred at.
      * @param cChannel One of the channels that the user is on
      * @param cChannelClient Client changing nickname
      * @param sOldNick Nickname before change
      */
-    protected void callChannelNickChanged(final ChannelInfo cChannel,
+    protected void callChannelNickChanged(final LocalDateTime date, final ChannelInfo cChannel,
             final ChannelClientInfo cChannelClient, final String sOldNick) {
         getCallbackManager().publish(
-                new ChannelNickChangeEvent(parser, LocalDateTime.now(), cChannel, cChannelClient,
+                new ChannelNickChangeEvent(parser, date, cChannel, cChannelClient,
                         sOldNick));
     }
 
     /**
      * Callback to all objects implementing the NickChanged Callback.
      *
+     * @param date The LocalDateTime that this event occurred at.
      * @param cClient Client changing nickname
      * @param sOldNick Nickname before change
      */
-    protected void callNickChanged(final ClientInfo cClient, final String sOldNick) {
-        getCallbackManager().publish(new NickChangeEvent(parser, LocalDateTime.now(), cClient,
+    protected void callNickChanged(final LocalDateTime date, final ClientInfo cClient, final String sOldNick) {
+        getCallbackManager().publish(new NickChangeEvent(parser, date, cClient,
                 sOldNick));
     }
 

irc/src/main/java/com/dmdirc/parser/irc/processors/ProcessNickInUse.java

      * @param token IRCTokenised line to process
      */
     @Override
-    public void process(final String sParam, final String... token) {
-        callNickInUse(token[3]);
+    public void process(final LocalDateTime time, final String sParam, final String... token) {
+        callNickInUse(time, token[3]);
     }
 
     /**
      *
      * @param nickname Nickname that was wanted.
      */
-    protected void callNickInUse(final String nickname) {
-        getCallbackManager().publish(new NickInUseEvent(parser, LocalDateTime.now(), nickname));
+    protected void callNickInUse(final LocalDateTime time, final String nickname) {
+        getCallbackManager().publish(new NickInUseEvent(parser, time, nickname));
     }
 
 }

irc/src/main/java/com/dmdirc/parser/irc/processors/ProcessNoticeAuth.java

      * @param token IRCTokenised line to process
      */
     @Override
-    public void process(final String sParam, final String... token) {
-        callNoticeAuth(token[token.length - 1]);
+    public void process(final LocalDateTime time, final String sParam, final String... token) {
+        callNoticeAuth(time, token[token.length - 1]);
     }
 
     /**
      *
      * @param data Incomming Line.
      */
-    protected void callNoticeAuth(final String data) {
-        getCallbackManager().publish(new AuthNoticeEvent(parser, LocalDateTime.now(), data));
+    protected void callNoticeAuth(final LocalDateTime time, final String data) {
+        getCallbackManager().publish(new AuthNoticeEvent(parser, time, data));
     }
 
 }

irc/src/main/java/com/dmdirc/parser/irc/processors/ProcessPart.java

     /**
      * Process a channel part.
      *
+     * @param date The LocalDateTime that this event occurred at.
      * @param sParam Type of line to process ("PART")
      * @param token IRCTokenised line to process
      */
     @Override
-    public void process(final String sParam, final String... token) {
+    public void process(final LocalDateTime date, final String sParam, final String... token) {
         // :nick!ident@host PART #Channel
         // :nick!ident@host PART #Channel :reason
         if (token.length < 3) {
                 return;
             }
             if (parser.getRemoveAfterCallback()) {
-                callChannelPart(iChannel, iChannelClient, sReason);
+                callChannelPart(date, iChannel, iChannelClient, sReason);
             }
             callDebugInfo(IRCParser.DEBUG_INFO, "Removing %s from %s", iClient.getNickname(), iChannel.getName());
             iChannel.delClient(iClient);
             if (!parser.getRemoveAfterCallback()) {
-                callChannelPart(iChannel, iChannelClient, sReason);
+                callChannelPart(date, iChannel, iChannelClient, sReason);
             }
             if (iClient == parser.getLocalClient()) {
                 iChannel.emptyChannel();
     /**
      * Callback to all objects implementing the ChannelPart Callback.
      *
+     * @param date The LocalDateTime that this event occurred at.
      * @param cChannel Channel that the user parted
      * @param cChannelClient Client that parted
      * @param sReason Reason given for parting (May be "")
      */
-    protected void callChannelPart(final ChannelInfo cChannel,
+    protected void callChannelPart(final LocalDateTime date, final ChannelInfo cChannel,
             final ChannelClientInfo cChannelClient, final String sReason) {
         getCallbackManager().publish(
-                new ChannelPartEvent(parser, LocalDateTime.now(), cChannel, cChannelClient,
+                new ChannelPartEvent(parser, date, cChannel, cChannelClient,
                         sReason));
     }
 

irc/src/main/java/com/dmdirc/parser/irc/processors/ProcessQuit.java

     /**
      * Process a Quit message.
      *
+     * @param date The LocalDateTime that this event occurred at.
      * @param sParam Type of line to process ("QUIT")
      * @param token IRCTokenised line to process
      */
     @Override
-    public void process(final String sParam, final String... token) {
+    public void process(final LocalDateTime date, final String sParam, final String... token) {
         // :nick!ident@host QUIT
         // :nick!ident@host QUIT :reason
         if (token.length < 2) {
             final IRCChannelClientInfo iChannelClient = iChannel.getChannelClient(iClient);
             if (iChannelClient != null) {
                 if (parser.getRemoveAfterCallback()) {
-                    callChannelQuit(iChannel, iChannelClient, sReason);
+                    callChannelQuit(date, iChannel, iChannelClient, sReason);
                 }
                 if (iClient == parser.getLocalClient()) {
                     iChannel.emptyChannel();
                     iChannel.delClient(iClient);
                 }
                 if (!parser.getRemoveAfterCallback()) {
-                    callChannelQuit(iChannel, iChannelClient, sReason);
+                    callChannelQuit(date, iChannel, iChannelClient, sReason);
                 }
             }
         }
 
         if (parser.getRemoveAfterCallback()) {
-            callQuit(iClient, sReason);
+            callQuit(date, iClient, sReason);
         }
         if (iClient == parser.getLocalClient()) {
             parser.clearClients();
             parser.removeClient(iClient);
         }
         if (!parser.getRemoveAfterCallback()) {
-            callQuit(iClient, sReason);
+            callQuit(date, iClient, sReason);
         }
     }
 
     /**
      * Callback to all objects implementing the ChannelQuit Callback.
      *
+     * @param date The LocalDateTime that this event occurred at.
      * @param cChannel Channel that user was on
      * @param cChannelClient User thats quitting
      * @param sReason Quit reason
      */
-    protected void callChannelQuit(final ChannelInfo cChannel,
+    protected void callChannelQuit(final LocalDateTime date, final ChannelInfo cChannel,
             final ChannelClientInfo cChannelClient, final String sReason) {
         getCallbackManager().publish(
-                new ChannelQuitEvent(parser, LocalDateTime.now(), cChannel, cChannelClient,
+                new ChannelQuitEvent(parser, date, cChannel, cChannelClient,
                         sReason));
     }
 
     /**
      * Callback to all objects implementing the Quit Callback.
      *
+     * @param date The LocalDateTime that this event occurred at.
      * @param cClient Client Quitting
      * @param sReason Reason for quitting (may be "")
      */
-    protected void callQuit(final ClientInfo cClient, final String sReason) {
-        getCallbackManager().publish(new QuitEvent(parser, LocalDateTime.now(), cClient, sReason));
+    protected void callQuit(final LocalDateTime date, final ClientInfo cClient, final String sReason) {
+        getCallbackManager().publish(new QuitEvent(parser, date, cClient, sReason));
     }
 
 }

irc/src/main/java/com/dmdirc/parser/irc/processors/ProcessTopic.java

     /**
      * Process a topic change.
      *
+     * @param date The LocalDateTime that this event occurred at.
      * @param sParam Type of line to process ("TOPIC", "332", "333")
      * @param token IRCTokenised line to process
      */
     @Override
-    public void process(final String sParam, final String... token) {
+    public void process(final LocalDateTime date, final String sParam, final String... token) {
         final IRCChannelInfo iChannel;
         switch (sParam) {
             case "332":
                             iChannel.setTopicTime(Long.parseLong(token[5]));
                         }
                     }
-                    callChannelTopic(iChannel, true);
+                    callChannelTopic(date, iChannel, true);
                 }   break;
             default:
                 if (IRCParser.ALWAYS_UPDATECLIENT) {
                 iChannel.setTopicTime(System.currentTimeMillis() / 1000);
                 iChannel.setTopicUser(token[0].charAt(0) == ':' ? token[0].substring(1) : token[0]);
                 iChannel.setInternalTopic(token[token.length - 1]);
-                callChannelTopic(iChannel, false);
+                callChannelTopic(date, iChannel, false);
                 break;
         }
     }
     /**
      * Callback to all objects implementing the ChannelTopic Callback.
      *
+     * @param date The LocalDateTime that this event occurred at.
      * @param cChannel Channel that topic was set on
      * @param bIsJoinTopic True when getting topic on join, false if set by user/server
      */
-    protected void callChannelTopic(final ChannelInfo cChannel, final boolean bIsJoinTopic) {
+    protected void callChannelTopic(final LocalDateTime date, final ChannelInfo cChannel, final boolean bIsJoinTopic) {
         ((IRCChannelInfo) cChannel).setHadTopic();
         getCallbackManager().publish(
-                new ChannelTopicEvent(parser, LocalDateTime.now(), cChannel, bIsJoinTopic));
+                new ChannelTopicEvent(parser, date, cChannel, bIsJoinTopic));
     }
 
 }

irc/src/main/java/com/dmdirc/parser/irc/processors/ProcessWallops.java

      * @param token IRCTokenised line to process
      */
     @Override
-    public void process(final String sParam, final String... token) {
+    public void process(final LocalDateTime time, final String sParam, final String... token) {
         if (token.length < 3) {
             return;
         }
 
         if (bits.length > 1) {
             if (message.charAt(0) == '*') {
-                callWallop(bits[1], user);
+                callWallop(time, bits[1], user);
                 return;
             } else if (message.charAt(0) == '$') {
-                callWalluser(bits[1], user);
+                callWalluser(time, bits[1], user);
                 return;
             }
         }
-        callWallDesync(message, user);
+        callWallDesync(time, message, user);
     }
 
     /**
      * @param message The message
      * @param host Host of the user who sent the wallop
      */
-    protected void callWallop(final String message, final String host) {
-        getCallbackManager().publish(new WallopEvent(parser, LocalDateTime.now(), message, host));
+    protected void callWallop(final LocalDateTime time, final String message, final String host) {
+        getCallbackManager().publish(new WallopEvent(parser, time, message, host));
     }
 
     /**
      * @param message The message
      * @param host Host of the user who sent the walluser
      */
-    protected void callWalluser(final String message, final String host) {
-        getCallbackManager().publish(new WalluserEvent(parser, LocalDateTime.now(), message, host));
+    protected void callWalluser(final LocalDateTime time, final String message, final String host) {
+        getCallbackManager().publish(new WalluserEvent(parser, time, message, host));
     }
 
     /**
      * @param message The message
      * @param host Host of the user who sent the WallDesync
      */
-    protected void callWallDesync(final String message, final String host) {
+    protected void callWallDesync(final LocalDateTime time, final String message, final String host) {
         getCallbackManager().publish(new WallDesyncEvent(
-                parser, LocalDateTime.now(), message, host));
+                parser, time, message, host));
     }
 
 }

irc/src/main/java/com/dmdirc/parser/irc/processors/ProcessWho.java

      * @param token IRCTokenised line to process
      */
     @Override
-    public void process(final String sParam, final String... token) {
+    public void process(final LocalDateTime time, final String sParam, final String... token) {
         // :blueyonder2.uk.quakenet.org 352 Dataforce #mdbot shane Tobavaj.users.quakenet.org *.quakenet.org Tobavaj G+x :3 Tobavaj - http://shane.dmdirc.com/scriptbot.php
         //              0               1      2        3     4              5                      6           7     8        9
         // :blueyonder2.uk.quakenet.org 352 Dataforce #mdbot ~Dataforce ResNetUser-BrynDinas-147.143.246.102.bangor.ac.uk *.quakenet.org Dataforce H@ :0 Dataforce
                 final AwayState oldState = client.getAwayState();
                 client.setAwayState(isAway);
                 if (client == parser.getLocalClient()) {
-                    callAwayState(oldState, client.getAwayState(), client.getAwayReason());
+                    callAwayState(time, oldState, client.getAwayState(), client.getAwayReason());
                 } else {
-                    callAwayStateOther(client, oldState, isAway);
+                    callAwayStateOther(time, client, oldState, isAway);
 
                     for (ChannelInfo iChannel : parser.getChannels()) {
                         final ChannelClientInfo iChannelClient = iChannel.getChannelClient(client);
                         if (iChannelClient != null) {
-                            callChannelAwayStateOther(iChannel, iChannelClient, oldState, isAway);
+                            callChannelAwayStateOther(time, iChannel, iChannelClient, oldState, isAway);
                         }
                     }
                 }
      * @param currentState Current Away State
      * @param reason Best guess at away reason
      */
-    protected void callAwayState(final AwayState oldState, final AwayState currentState,
+    protected void callAwayState(final LocalDateTime time, final AwayState oldState, final AwayState currentState,
             final String reason) {
         getCallbackManager().publish(
-                new AwayStateEvent(parser, LocalDateTime.now(), oldState, currentState, reason));
+                new AwayStateEvent(parser, time, oldState, currentState, reason));
     }
 
     /**
      * @param oldState Old Away State
      * @param state Current Away State
      */
-    protected void callAwayStateOther(final ClientInfo client, final AwayState oldState,
+    protected void callAwayStateOther(final LocalDateTime time, final ClientInfo client, final AwayState oldState,
             final AwayState state) {
         getCallbackManager().publish(
-                new OtherAwayStateEvent(parser, LocalDateTime.now(), client, oldState, state));
+                new OtherAwayStateEvent(parser, time, client, oldState, state));
     }
 
     /**
      * @param oldState Old Away State
      * @param state Current Away State
      */
-    protected void callChannelAwayStateOther(final ChannelInfo channel,
+    protected void callChannelAwayStateOther(final LocalDateTime time, final ChannelInfo channel,
             final ChannelClientInfo channelClient, final AwayState oldState, final AwayState state) {
         getCallbackManager().publish(
-                new ChannelOtherAwayStateEvent(parser, LocalDateTime.now(), channel, channelClient,
+                new ChannelOtherAwayStateEvent(parser, time, channel, channelClient,
                         oldState, state));
     }
 

irc/src/test/java/com/dmdirc/parser/irc/processors/Process001Test.java

 import org.mockito.Mock;
 import org.mockito.runners.MockitoJUnitRunner;
 
+import java.time.LocalDateTime;
+
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assume.assumeFalse;
     public void testSets001Received() {
         when(localClient.isFake()).thenReturn(true);
         assumeFalse(parser.got001);
-        processor.process("001", ":test.server.com", "001", "userName", "Hello!");
+        processor.process(LocalDateTime.now(), "001", ":test.server.com", "001", "userName", "Hello!");
         assertTrue(parser.got001);
     }
 
     @Test
     public void testUpdatesServerName() {
         when(localClient.isFake()).thenReturn(true);
-        processor.process("001", ":test.server.com", "001", "userName", "Hello!");
+        processor.process(LocalDateTime.now(), "001", ":test.server.com", "001", "userName", "Hello!");
         verify(parser).updateServerName("test.server.com");
     }
 
     @Test
     public void testAddsLocalClientIfFake() {
         when(localClient.isFake()).thenReturn(true);
-        processor.process("001", ":test.server.com", "001", "userName", "Hello!");
+        processor.process(LocalDateTime.now(), "001", ":test.server.com", "001", "userName", "Hello!");
         verify(parser).addClient(localClient);
     }
 
     @Test
     public void testUpdatesLocalClientIfFake() {
         when(localClient.isFake()).thenReturn(true);
-        processor.process("001", ":test.server.com", "001", "userName", "Hello!");
+        processor.process(LocalDateTime.now(), "001", ":test.server.com", "001", "userName", "Hello!");
         verify(localClient).setUserBits(eq("userName"), eq(true), anyBoolean());
         verify(localClient).setFake(false);
     }
     @Test
     public void testIgnoresDuplicate001WithSameNick() {
         when(localClient.getNickname()).thenReturn("UsernaME");
-        processor.process("001", ":test.server.com", "001", "userName", "Hello!");
+        processor.process(LocalDateTime.now(), "001", ":test.server.com", "001", "userName", "Hello!");
         verify(parser, never()).addClient(any());
         verify(parser, never()).forceRemoveClient(any());
     }
     @Test
     public void testReplacesLocalUserOnDuplicate001() {
         when(localClient.getNickname()).thenReturn("UsernaME");
-        processor.process("001", ":test.server.com", "001", "newName", "Hello!");
+        processor.process(LocalDateTime.now(), "001", ":test.server.com", "001", "newName", "Hello!");
         verify(parser).forceRemoveClient(localClient);
         verify(localClient).setUserBits(eq("newName"), eq(true), anyBoolean());
         verify(parser).addClient(localClient);
         when(parser.isKnownClient("newName")).thenReturn(true);
         when(parser.getClient("newName")).thenReturn(mock(IRCClientInfo.class));
 
-        processor.process("001", ":test.server.com", "001", "newName", "Hello!");
+        processor.process(LocalDateTime.now(), "001", ":test.server.com", "001", "newName", "Hello!");
 
         final ArgumentCaptor<ParserError> errorCaptor = ArgumentCaptor.forClass(ParserError.class);
         verify(parser).callErrorInfo(errorCaptor.capture());

irc/src/test/java/com/dmdirc/parser/irc/processors/Process464Test.java

 import org.mockito.Mock;
 import org.mockito.runners.MockitoJUnitRunner;
 
+import java.time.LocalDateTime;
+
 import static org.junit.Assert.assertSame;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
     @Test
     public void testFiresPasswordListenerOn464() {
-        processor.process("464", ":server.com", "464", ":Bad password!");
+        processor.process(LocalDateTime.now(), "464", ":server.com", "464", ":Bad password!");
         verify(callbackManager).publish(eventCaptor.capture());
         assertSame(parser, eventCaptor.getValue().getParser());
     }