Stop ClientInfo being static.

.gitignore

 # DMDirc .gitignore file
 /build
+/generated
 /dist
 /lib
 /etc/clover.license

build.gradle

 dependencies {
     compile group: 'com.google.code.findbugs', name: 'jsr305', version: '3.0.0'
     compile group: 'com.squareup.dagger', name: 'dagger-compiler', version: '1.2.1'
+    compile group: 'com.google.auto.value', name: 'auto-value', version: '1.0-rc1'
 
     bundle group: 'com.squareup.dagger', name: 'dagger', version: '1.2.1'
     bundle group: 'com.esotericsoftware.yamlbeans', name: 'yamlbeans', version: '1.08'

src/com/dmdirc/config/ConfigManager.java

     private final ConfigBinder binder = new ConfigBinder(this);
     /** The manager to use to fetch global state. */
     private final IdentityManager manager;
+    /** Client info object. */
+    private final ClientInfo clientInfo;
     /** The protocol this manager is for. */
     private String protocol;
     /** The ircd this manager is for. */
      * @since 0.6.3
      */
     ConfigManager(
+            final ClientInfo clientInfo,
             final IdentityManager manager,
             final String protocol, final String ircd,
             final String network, final String server) {
-        this(manager, protocol, ircd, network, server, "<Unknown>");
+        this(clientInfo, manager, protocol, ircd, network, server, "<Unknown>");
     }
 
     /**
      * @since 0.6.3
      */
     ConfigManager(
+            final ClientInfo clientInfo,
             final IdentityManager manager,
             final String protocol, final String ircd,
             final String network, final String server, final String channel) {
-        final String chanName = channel + "@" + network;
+        final String chanName = channel + '@' + network;
 
+        this.clientInfo = clientInfo;
         this.manager = manager;
         this.protocol = protocol;
         this.ircd = ircd;
         doStats(domain, option);
 
         if (VERSION_DOMAIN.equals(domain)) {
-            final String response = ClientInfo.getVersionConfigSetting(VERSION_DOMAIN, option);
+            final String response = clientInfo.getVersionConfigSetting(VERSION_DOMAIN, option);
             if (response == null || validator.validate(response).isFailure()) {
                 return null;
             }
         doStats(domain, option);
 
         if (VERSION_DOMAIN.equals(domain)) {
-            final String response = ClientInfo.getVersionConfigSetting(VERSION_DOMAIN, option);
+            final String response = clientInfo.getVersionConfigSetting(VERSION_DOMAIN, option);
             return response != null && !validator.validate(response).isFailure();
         }
 

src/com/dmdirc/config/ConfigModule.java

 import com.dmdirc.logger.ErrorManager;
 import com.dmdirc.logger.Logger;
 import com.dmdirc.ui.WarningDialog;
+import com.dmdirc.util.ClientInfo;
 
 import java.awt.GraphicsEnvironment;
 import java.io.IOException;
             @Directory(DirectoryType.IDENTITIES) final Path identitiesDirectory,
             @Directory(DirectoryType.ERRORS) final Path errorsDirectory,
             final CommandLineParser commandLineParser,
-            final DMDircMBassador eventBus) {
+            final DMDircMBassador eventBus,
+            final ClientInfo clientInfo) {
         final IdentityManager identityManager = new IdentityManager(baseDirectory,
-                identitiesDirectory, eventBus);
+                identitiesDirectory, eventBus, clientInfo);
         ErrorManager.getErrorManager()
-                .initialise(identityManager.getGlobalConfiguration(), errorsDirectory, eventBus);
+                .initialise(identityManager.getGlobalConfiguration(), errorsDirectory, eventBus,
+                        clientInfo);
         identityManager.loadVersionIdentity();
 
         try {

src/com/dmdirc/config/IdentityManager.java

 import com.dmdirc.interfaces.config.IdentityController;
 import com.dmdirc.interfaces.config.IdentityFactory;
 import com.dmdirc.logger.ErrorLevel;
+import com.dmdirc.util.ClientInfo;
 import com.dmdirc.util.collections.MapList;
 import com.dmdirc.util.collections.WeakMapList;
 import com.dmdirc.util.io.ConfigFile;
      * specific custom type use their type as the key.
      */
     private final MapList<String, ConfigProviderListener> listeners = new WeakMapList<>();
+    /** Client info objecty. */
+    private final ClientInfo clientInfo;
     /** The identity file used for the global config. */
     private ConfigProvider config;
     /** The identity file used for addon defaults. */
      * @param eventBus            The event bus to post events to
      */
     public IdentityManager(final Path baseDirectory, final Path identitiesDirectory,
-            final DMDircMBassador eventBus) {
+            final DMDircMBassador eventBus, final ClientInfo clientInfo) {
         this.configDirectory = baseDirectory;
         this.identitiesDirectory = identitiesDirectory;
         this.eventBus = eventBus;
+        this.clientInfo = clientInfo;
     }
 
     /**
     @Override
     public ConfigProviderMigrator createMigratableConfig(final String protocol,
             final String ircd, final String network, final String server) {
-        final ConfigManager configManager = new ConfigManager(this, protocol, ircd, network, server);
+        final ConfigManager configManager = new ConfigManager(clientInfo, this, protocol, ircd,
+                network, server);
         setUpConfigManager(configManager);
         return new ConfigManagerMigrator(configManager);
     }
     @Override
     public ConfigProviderMigrator createMigratableConfig(final String protocol,
             final String ircd, final String network, final String server, final String channel) {
-        final ConfigManager configManager = new ConfigManager(this, protocol, ircd, network, server,
-                channel);
+        final ConfigManager configManager = new ConfigManager(clientInfo, this, protocol, ircd,
+                network, server, channel);
         setUpConfigManager(configManager);
         return new ConfigManagerMigrator(configManager);
     }
     @Override
     public AggregateConfigProvider createAggregateConfig(final String protocol, final String ircd,
             final String network, final String server) {
-        final ConfigManager configManager = new ConfigManager(this, protocol, ircd, network, server);
+        final ConfigManager configManager = new ConfigManager(clientInfo, this, protocol, ircd,
+                network, server);
         setUpConfigManager(configManager);
         return configManager;
     }
     @Override
     public AggregateConfigProvider createAggregateConfig(final String protocol, final String ircd,
             final String network, final String server, final String channel) {
-        final ConfigManager configManager = new ConfigManager(this, protocol, ircd, network, server,
-                channel);
+        final ConfigManager configManager = new ConfigManager(clientInfo, this, protocol, ircd,
+                network, server, channel);
         setUpConfigManager(configManager);
         return configManager;
     }

src/com/dmdirc/logger/ErrorManager.java

 import com.dmdirc.interfaces.config.AggregateConfigProvider;
 import com.dmdirc.interfaces.config.ConfigChangeListener;
 import com.dmdirc.ui.FatalErrorDialog;
+import com.dmdirc.util.ClientInfo;
 import com.dmdirc.util.collections.ListenerList;
 
 import java.awt.GraphicsEnvironment;
     private AggregateConfigProvider config;
     /** Directory to store errors in. */
     private Path errorsDirectory;
+    private ClientInfo clientInfo;
 
     /** Creates a new instance of ErrorListDialog. */
     public ErrorManager() {
      * @param eventBus     The event bus to listen for error events on.
      */
     public void initialise(final AggregateConfigProvider globalConfig, final Path directory,
-            final DMDircMBassador eventBus) {
+            final DMDircMBassador eventBus, final ClientInfo clientInfo) {
+        this.clientInfo = clientInfo;
         eventBus.subscribe(this);
         RavenFactory.registerFactory(new DefaultRavenFactory());
 
     protected ProgramError getError(final ErrorLevel level, final String message,
             final Throwable exception, final String details) {
         return new ProgramError(nextErrorID.getAndIncrement(), level, message, exception,
-                details, new Date());
+                details, new Date(), clientInfo);
     }
 
     /**

src/com/dmdirc/logger/ErrorReporter.java

             + "e0a8aa1ecca14568a9f52d052ecf6a30@sentry.dmdirc.com/2?raven.async=false";
     /** Template to use when sending mode alias reports. */
     private static final String MODE_ALIAS_TEMPLATE = "%s\n\nConnection headers:\n%s";
+    private final ClientInfo clientInfo;
+
+    public ErrorReporter(final ClientInfo clientInfo) {
+        this.clientInfo = clientInfo;
+    }
 
     /**
      * Sends an error report caused by some kind of exception.
     private EventBuilder newEventBuilder() {
         return new EventBuilder()
                 .setServerName("")
-                .addTag("version", ClientInfo.getVersion())
-                .addTag("version.major", ClientInfo.getMajorVersion())
-                .addTag("os.name", ClientInfo.getOperatingSystemName())
-                .addTag("os.version", ClientInfo.getOperatingSystemVersion())
-                .addTag("os.arch", ClientInfo.getOperatingSystemArchitecture())
-                .addTag("encoding", ClientInfo.getSystemFileEncoding())
-                .addTag("locale", ClientInfo.getSystemDefaultLocale())
-                .addTag("jvm.name", ClientInfo.getJavaName())
-                .addTag("jvm.vendor", ClientInfo.getJavaVendor())
-                .addTag("jvm.version", ClientInfo.getJavaVersion())
-                .addTag("jvm.version.major", ClientInfo.getJavaMajorVersion());
+                .addTag("version", clientInfo.getVersion())
+                .addTag("version.major", clientInfo.getMajorVersion())
+                .addTag("os.name", clientInfo.getOperatingSystemName())
+                .addTag("os.version", clientInfo.getOperatingSystemVersion())
+                .addTag("os.arch", clientInfo.getOperatingSystemArchitecture())
+                .addTag("encoding", clientInfo.getSystemFileEncoding())
+                .addTag("locale", clientInfo.getSystemDefaultLocale())
+                .addTag("jvm.name", clientInfo.getJavaName())
+                .addTag("jvm.vendor", clientInfo.getJavaVendor())
+                .addTag("jvm.version", clientInfo.getJavaVersion())
+                .addTag("jvm.version.major", clientInfo.getJavaMajorVersion());
     }
 
     /**

src/com/dmdirc/logger/ProgramError.java

 
 package com.dmdirc.logger;
 
+import com.dmdirc.util.ClientInfo;
+
 import java.io.IOException;
 import java.io.OutputStream;
 import java.io.PrintWriter;
     public ProgramError(final long id, final ErrorLevel level, final String message,
             @Nullable final Throwable exception,
             @Nullable final String details,
-            final Date date) {
+            final Date date,
+            final ClientInfo clientInfo) {
 
         if (id < 0) {
             throw new IllegalArgumentException("ID must be a positive integer: " + id);
         this.lastDate = (Date) date.clone();
         this.count = new AtomicInteger(1);
         this.reportStatus = ErrorReportStatus.WAITING;
-        this.reporter = new ErrorReporter();
+        this.reporter = new ErrorReporter(clientInfo);
     }
 
     /**

src/com/dmdirc/ui/core/feedback/CoreFeedbackDialogModel.java

     private final AggregateConfigProvider config;
     private final ConnectionManager connectionManager;
     private final Path configDirectory;
+    private final ClientInfo clientInfo;
     private Optional<String> name;
     private Optional<String> email;
     private Optional<String> feedback;
     @Inject
     public CoreFeedbackDialogModel(@ClientModule.GlobalConfig final AggregateConfigProvider config,
             final ConnectionManager connectionManager, final FeedbackSenderFactory feedbackSenderFactory,
-            @Directory(DirectoryType.BASE) final Path configDirectory) {
+            @Directory(DirectoryType.BASE) final Path configDirectory,
+            final ClientInfo clientInfo) {
         this.connectionManager = connectionManager;
         this.configDirectory = configDirectory;
         this.feedbackSenderFactory = feedbackSenderFactory;
         this.config = config;
+        this.clientInfo = clientInfo;
         this.listeners = new ListenerList();
         name = Optional.empty();
         email = Optional.empty();
             }
         }
         if (getIncludeDMDircInfo()) {
-            dmdircInfo.append("DMDirc version: ").append(ClientInfo.getVersionInformation())
+            dmdircInfo.append("DMDirc version: ").append(clientInfo.getVersionInformation())
                     .append('\n');
             dmdircInfo.append("Profile directory: ").append(configDirectory).append('\n');
-            dmdircInfo.append("Java version: ").append(ClientInfo.getJavaInformation())
+            dmdircInfo.append("Java version: ").append(clientInfo.getJavaInformation())
                     .append('\n');
-            dmdircInfo.append("OS Version: ").append(ClientInfo.getOperatingSystemInformation());
+            dmdircInfo.append("OS Version: ").append(clientInfo.getOperatingSystemInformation());
         }
         final FeedbackSender sender = feedbackSenderFactory.getFeedbackSender(
                 name.orElse(""), email.orElse(""), feedback.orElse(""),

src/com/dmdirc/util/ClientInfo.java

 import java.lang.management.ManagementFactory;
 import java.util.Locale;
 
+import javax.inject.Inject;
+import javax.inject.Singleton;
+
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 /**
  * Provides static utility methods to access information about the client and its environment.
  */
-public final class ClientInfo {
+@Singleton
+public class ClientInfo {
 
     private static final Logger LOG = LoggerFactory.getLogger(ClientInfo.class);
     /** Domain to read version settings from. */
     /** Fallback value to use if a system property isn't found. */
     private static final String PROPERTY_FALLBACK = "unknown";
     /** Lock used to guard access to {@link #versionConfig}. */
-    private static final Object VERSION_CONFIG_LOCK = new Object();
+    private final Object VERSION_CONFIG_LOCK = new Object();
     /** Cached config file containing the client's version information. */
-    private static ConfigFile versionConfig;
+    private ConfigFile versionConfig;
 
-    private ClientInfo() {
+    @Inject
+    public ClientInfo() {
         // Shouldn't be initialised.
     }
 
     /**
      * @return The version of the client.
      */
-    public static String getVersion() {
+    public String getVersion() {
         return getVersionConfigSetting(VERSION_DOMAIN, VERSION_KEY);
     }
 
     /**
      * @return The major version of the client.
      */
-    public static String getMajorVersion() {
+    public String getMajorVersion() {
         return getVersion().replaceAll("(-|rc|a|b|m).*", "");
     }
 
     /**
      * @return The channel that this client was built for.
      */
-    public static String getUpdaterChannel() {
+    public String getUpdaterChannel() {
         return getVersionConfigSetting(UPDATER_DOMAIN, UPDATER_CHANNEL_KEY);
     }
 
     /**
      * @return The name of the operating system the client is running on.
      */
-    public static String getOperatingSystemName() {
+    public String getOperatingSystemName() {
         return System.getProperty("os.name", PROPERTY_FALLBACK);
     }
 
     /**
      * @return The version of the operating system the client is running on.
      */
-    public static String getOperatingSystemVersion() {
+    public String getOperatingSystemVersion() {
         return System.getProperty("os.version", PROPERTY_FALLBACK);
     }
 
     /**
      * @return The name of the architecture that the operating system is built for.
      */
-    public static String getOperatingSystemArchitecture() {
+    public String getOperatingSystemArchitecture() {
         return System.getProperty("os.arch", PROPERTY_FALLBACK);
     }
 
     /**
      * @return The default file encoding used by the system.
      */
-    public static String getSystemFileEncoding() {
+    public String getSystemFileEncoding() {
         return System.getProperty("file.encoding", PROPERTY_FALLBACK);
     }
 
     /**
      * @return The default locale used by the system.
      */
-    public static String getSystemDefaultLocale() {
+    public String getSystemDefaultLocale() {
         return Locale.getDefault().toString();
     }
 
     /**
      * @return The name of the JVM running the client.
      */
-    public static String getJavaName() {
+    public String getJavaName() {
         return System.getProperty("java.vm.name", PROPERTY_FALLBACK);
     }
 
     /**
      * @return The name of the vendor of the JVM running the client.
      */
-    public static String getJavaVendor() {
+    public String getJavaVendor() {
         return System.getProperty("java.vm.vendor", PROPERTY_FALLBACK);
     }
 
     /**
      * @return The version of the JVM running the client.
      */
-    public static String getJavaVersion() {
+    public String getJavaVersion() {
         return System.getProperty("java.version", PROPERTY_FALLBACK);
     }
 
     /**
      * @return The major version of the JVM running the client.
      */
-    public static String getJavaMajorVersion() {
+    public String getJavaMajorVersion() {
         return getJavaVersion().replaceAll("_.*", "");
     }
 
     /**
      * @return The uptime for the client in milliseconds.
      */
-    public static long getUptime() {
+    public long getUptime() {
         return ManagementFactory.getRuntimeMXBean().getUptime();
     }
 
     /**
      * @return A string containing the DMDirc version and updater channel.
      */
-    public static String getVersionInformation() {
-        return getVersion() + " (" + getUpdaterChannel() + ")";
+    public String getVersionInformation() {
+        return getVersion() + " (" + getUpdaterChannel() + ')';
     }
 
     /**
      * @return A string containing the JVM name, version, and vendor.
      */
-    public static String getJavaInformation() {
-        return getJavaName() + " " + getJavaVersion() + " [" + getJavaVendor() + "]";
+    public String getJavaInformation() {
+        return getJavaName() + ' ' + getJavaVersion() + " [" + getJavaVendor() + ']';
     }
 
     /**
      * @return A string containing the OS name, version and architecture, and the default file
      *         encoding and locale.
      */
-    public static String getOperatingSystemInformation() {
-        return getOperatingSystemName() + " "
-                + getOperatingSystemVersion() + " "
+    public String getOperatingSystemInformation() {
+        return getOperatingSystemName() + ' '
+                + getOperatingSystemVersion() + ' '
                 + getOperatingSystemArchitecture() + "; "
                 + getSystemFileEncoding() + "; "
                 + getSystemDefaultLocale();
      *
      * @return The value of the key within the version config, or {@code null} if it doesn't exist.
      */
-    public static String getVersionConfigSetting(final String domain, final String key) {
+    public String getVersionConfigSetting(final String domain, final String key) {
         return getVersionConfig().getKeyDomain(domain).get(key);
     }
 
      *
      * @return The client's bundled version config file.
      */
-    private static ConfigFile getVersionConfig() {
+    private ConfigFile getVersionConfig() {
         synchronized (VERSION_CONFIG_LOCK) {
             if (versionConfig == null) {
                 LOG.debug("No previous version config cached, creating a new one...");

test/com/dmdirc/config/ConfigManagerTest.java

 package com.dmdirc.config;
 
 import com.dmdirc.interfaces.config.ConfigChangeListener;
+import com.dmdirc.util.ClientInfo;
 import com.dmdirc.util.validators.PermissiveValidator;
 
 import org.junit.Test;
 import org.mockito.Mock;
 import org.mockito.runners.MockitoJUnitRunner;
 
-import static org.junit.Assert.*;
-import static org.mockito.Mockito.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.mockito.Mockito.anyString;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
 
 @RunWith(MockitoJUnitRunner.class)
 public class ConfigManagerTest {
 
     @Mock private IdentityManager identityManager;
+    @Mock private ClientInfo clientInfo;
 
     @Test
     public void testNonExistantOption() {
-        assertNull(new ConfigManager(identityManager, "", "", "", "")
+        assertNull(new ConfigManager(clientInfo, identityManager, "", "", "", "")
                 .getOption("unit-test123", "foobar"));
     }
 
     @Test
     public void testStats() {
-        final ConfigManager cm = new ConfigManager(identityManager, "", "", "", "");
+        final ConfigManager cm = new ConfigManager(clientInfo, identityManager, "", "", "", "");
         assertNull(ConfigManager.getStats().get("unit-test123.baz"));
         cm.hasOption("unit-test123", "baz", new PermissiveValidator<String>());
         assertNotNull(ConfigManager.getStats().get("unit-test123.baz"));
     @Test
     public void testDomainListener() {
         final ConfigChangeListener listener = mock(ConfigChangeListener.class);
-        final ConfigManager cm = new ConfigManager(identityManager, "", "", "", "");
+        final ConfigManager cm = new ConfigManager(clientInfo, identityManager, "", "", "", "");
         cm.addChangeListener("unit-test", listener);
 
         cm.configChanged("foo", "bar");
     @Test
     public void testDomainKeyListener() {
         final ConfigChangeListener listener = mock(ConfigChangeListener.class);
-        final ConfigManager cm = new ConfigManager(identityManager, "", "", "", "");
+        final ConfigManager cm = new ConfigManager(clientInfo, identityManager, "", "", "", "");
         cm.addChangeListener("unit-test", "foo", listener);
 
         cm.configChanged("foo", "bar");

test/com/dmdirc/config/IdentityManagerTest.java

 
 import com.dmdirc.DMDircMBassador;
 import com.dmdirc.interfaces.config.ConfigProvider;
+import com.dmdirc.util.ClientInfo;
 
 import com.google.common.jimfs.Configuration;
 import com.google.common.jimfs.Jimfs;
 public class IdentityManagerTest {
 
     @Mock private DMDircMBassador eventBus;
+    @Mock private ClientInfo clientInfo;
 
     private Path baseDirectory;
     private Path identitiesDirectory;
     @Test
     public void testLoadsVersionIdentity() throws InvalidIdentityFileException {
         final IdentityManager identityManager = new IdentityManager(
-                baseDirectory, identitiesDirectory, eventBus);
+                baseDirectory, identitiesDirectory, eventBus, clientInfo);
         identityManager.initialise();
 
         final ConfigProvider versionSettings = identityManager.getVersionSettings();
     @Test
     public void testUsesSystemUsernameForProfileNickname() throws InvalidIdentityFileException {
         final IdentityManager identityManager = new IdentityManager(
-                baseDirectory, identitiesDirectory, eventBus);
+                baseDirectory, identitiesDirectory, eventBus, clientInfo);
         identityManager.initialise();
 
         System.setProperty("user.name", "Awesome User");
                 identitiesDirectory.resolve("profile"));
 
         final IdentityManager identityManager = new IdentityManager(
-                baseDirectory, identitiesDirectory, eventBus);
+                baseDirectory, identitiesDirectory, eventBus, clientInfo);
         identityManager.initialise();
 
         final List<ConfigProvider> profiles = identityManager.getProvidersByType("profile");

test/com/dmdirc/logger/ErrorReporterTest.java

 
 package com.dmdirc.logger;
 
+import com.dmdirc.util.ClientInfo;
+
 import java.util.Date;
 
 import org.junit.Before;
     @Before
     public void setUp() {
         when(ravenFactory.createRavenInstance(Matchers.<Dsn>anyObject())).thenReturn(raven);
-        errorReporter = new ErrorReporter();
+        errorReporter = new ErrorReporter(new ClientInfo());
     }
 
     @Test

test/com/dmdirc/logger/ProgramErrorTest.java

 
 package com.dmdirc.logger;
 
+import com.dmdirc.util.ClientInfo;
+
 import java.util.Date;
 
 import org.junit.Before;
 public class ProgramErrorTest {
 
     @Mock private ErrorManager errorManager;
+    @Mock private ClientInfo clientInfo;
 
     @Before
     public void setup() {
 
     @Test(expected = IllegalArgumentException.class)
     public void testConstructorNegativeID() {
-        new ProgramError(-1, ErrorLevel.HIGH, "moo", null, null, new Date());
+        new ProgramError(-1, ErrorLevel.HIGH, "moo", null, null, new Date(), clientInfo);
     }
 
     @Test(expected = IllegalArgumentException.class)
     public void testConstructorNullErrorLevel() {
-        new ProgramError(1, null, "moo", null, null, new Date());
+        new ProgramError(1, null, "moo", null, null, new Date(), clientInfo);
     }
 
     @Test(expected = IllegalArgumentException.class)
     public void testConstructorNullMessage() {
-        new ProgramError(1, ErrorLevel.HIGH, null, null, null, new Date());
+        new ProgramError(1, ErrorLevel.HIGH, null, null, null, new Date(), clientInfo);
     }
 
     @Test(expected = IllegalArgumentException.class)
     public void testConstructorEmptyMessage() {
-        new ProgramError(1, ErrorLevel.HIGH, "", null, null, new Date());
+        new ProgramError(1, ErrorLevel.HIGH, "", null, null, new Date(), clientInfo);
     }
 
     @Test(expected = IllegalArgumentException.class)
     public void testConstructorNullDate() {
-        new ProgramError(1, ErrorLevel.HIGH, "moo", null, null, null);
+        new ProgramError(1, ErrorLevel.HIGH, "moo", null, null, null, clientInfo);
     }
 
     @Test
     public void testConstructorGood() {
-        new ProgramError(1, ErrorLevel.HIGH, "moo", new UnsupportedOperationException(), null, new Date());
+        new ProgramError(1, ErrorLevel.HIGH, "moo", new UnsupportedOperationException(),
+                null, new Date(), clientInfo);
     }
 
     @Test
     public void testGetLevel() {
         final ProgramError pe = new ProgramError(1, ErrorLevel.HIGH, "moo",
-                new UnsupportedOperationException(), null, new Date());
+                new UnsupportedOperationException(), null, new Date(), clientInfo);
         assertEquals(ErrorLevel.HIGH, pe.getLevel());
     }
 
     @Test
     public void testGetMessage() {
         final ProgramError pe = new ProgramError(1, ErrorLevel.HIGH, "moo",
-                new UnsupportedOperationException(), null, new Date());
+                new UnsupportedOperationException(), null, new Date(), clientInfo);
         assertEquals("moo", pe.getMessage());
     }
 
     public void testGetDate() {
         final Date date = new Date();
         final ProgramError pe = new ProgramError(1, ErrorLevel.HIGH, "moo",
-                new UnsupportedOperationException(), null, date);
+                new UnsupportedOperationException(), null, date, clientInfo);
         assertEquals(date, pe.getDate());
     }
 
     @Test
     public void testReportStatus() {
         final ProgramError pe = new ProgramError(1, ErrorLevel.HIGH, "moo",
-                new UnsupportedOperationException(), null, new Date());
+                new UnsupportedOperationException(), null, new Date(), clientInfo);
         assertEquals(ErrorReportStatus.WAITING, pe.getReportStatus());
         pe.setReportStatus(null);
         assertEquals(ErrorReportStatus.WAITING, pe.getReportStatus());
     @Test
     public void testToString() {
         final ProgramError pe = new ProgramError(1, ErrorLevel.HIGH, "moo",
-                new UnsupportedOperationException(), null, new Date());
+                new UnsupportedOperationException(), null, new Date(), clientInfo);
         assertTrue(pe.toString().contains("moo"));
     }
 
     public void testEquals() {
         final Exception ex = new UnsupportedOperationException();
         final ProgramError pe1 = new ProgramError(10, ErrorLevel.LOW, "moo",
-                ex, null, new Date());
+                ex, null, new Date(), clientInfo);
         final ProgramError pe2 = new ProgramError(11, ErrorLevel.LOW, "moo",
-                ex, null, new Date());
+                ex, null, new Date(), clientInfo);
         final ProgramError pe3 = new ProgramError(10, ErrorLevel.MEDIUM, "moo",
-                ex, null, new Date());
+                ex, null, new Date(), clientInfo);
         final ProgramError pe4 = new ProgramError(10, ErrorLevel.LOW, "bar",
-                ex, null, new Date());
+                ex, null, new Date(), clientInfo);
         final ProgramError pe5 = new ProgramError(10, ErrorLevel.LOW, "moo",
-                null, "Hello", new Date());
+                null, "Hello", new Date(), clientInfo);
 
         assertFalse(pe1.equals(null)); // NOPMD
         assertFalse(pe1.equals("moo"));

test/com/dmdirc/ui/core/feedback/CoreFeedbackDialogModelTest.java

 import com.dmdirc.interfaces.ConnectionManager;
 import com.dmdirc.interfaces.config.AggregateConfigProvider;
 import com.dmdirc.interfaces.ui.FeedbackDialogModelListener;
+import com.dmdirc.util.ClientInfo;
 
 import java.nio.file.Path;
 import java.util.Optional;
     @Mock private FeedbackSenderFactory feedbackSenderFactory;
     @Mock private FeedbackDialogModelListener listener;
     @Mock private Path path;
+    @Mock private ClientInfo clientInfo;
     private static final String NAME = "Bob Dole";
     private static final String EMAIL = "bob@dole.com";
     private static final String FEEDBACK = "DMDirc Rocks.";
     @Test
     public void testName() {
         final CoreFeedbackDialogModel instance = new CoreFeedbackDialogModel(config,
-                connectionManager,
-                feedbackSenderFactory, path);
+                connectionManager, feedbackSenderFactory, path, clientInfo);
         assertEquals("testName", Optional.empty(), instance.getName());
         instance.setName(Optional.ofNullable(NAME));
         assertEquals("testName", Optional.ofNullable(NAME), instance.getName());
     @Test
     public void testEmail() {
         final CoreFeedbackDialogModel instance = new CoreFeedbackDialogModel(config,
-                connectionManager,
-                feedbackSenderFactory, path);
+                connectionManager, feedbackSenderFactory, path, clientInfo);
         assertEquals("testEmail", Optional.empty(), instance.getEmail());
         instance.setEmail(Optional.ofNullable(EMAIL));
         assertEquals("testEmail", Optional.ofNullable(EMAIL), instance.getEmail());
     @Test
     public void testFeedback() {
         final CoreFeedbackDialogModel instance = new CoreFeedbackDialogModel(config,
-                connectionManager,
-                feedbackSenderFactory, path);
+                connectionManager, feedbackSenderFactory, path, clientInfo);
         assertEquals("testFeedback", Optional.empty(), instance.getFeedback());
         instance.setFeedback(Optional.ofNullable(FEEDBACK));
         assertEquals("testFeedback", Optional.ofNullable(FEEDBACK), instance.getFeedback());
     @Test
     public void testServerInfo() {
         final CoreFeedbackDialogModel instance = new CoreFeedbackDialogModel(config,
-                connectionManager,
-                feedbackSenderFactory, path);
+                connectionManager, feedbackSenderFactory, path, clientInfo);
         assertEquals("testServerInfo", false, instance.getIncludeServerInfo());
         instance.setIncludeServerInfo(true);
         assertEquals("testServerInfo", true, instance.getIncludeServerInfo());
     @Test
     public void testDMDircInfo() {
         final CoreFeedbackDialogModel instance = new CoreFeedbackDialogModel(config,
-                connectionManager,
-                feedbackSenderFactory, path);
+                connectionManager, feedbackSenderFactory, path, clientInfo);
         assertEquals("testDMDircInfo", false, instance.getIncludeDMDircInfo());
         instance.setIncludeDMDircInfo(true);
         assertEquals("testDMDircInfo", true, instance.getIncludeDMDircInfo());
     @Test
     public void testNameListener() {
         final CoreFeedbackDialogModel instance = new CoreFeedbackDialogModel(config,
-                connectionManager,
-                feedbackSenderFactory, path);
+                connectionManager, feedbackSenderFactory, path, clientInfo);
         instance.addListener(listener);
         instance.setName(Optional.ofNullable("Bob Dole"));
         verify(listener).nameChanged(Optional.ofNullable("Bob Dole"));
     @Test
     public void testEmailListener() {
         final CoreFeedbackDialogModel instance = new CoreFeedbackDialogModel(config,
-                connectionManager,
-                feedbackSenderFactory, path);
+                connectionManager, feedbackSenderFactory, path, clientInfo);
         instance.addListener(listener);
         instance.setEmail(Optional.ofNullable("bob@dole.com"));
         verify(listener).emailChanged(Optional.ofNullable("bob@dole.com"));
     @Test
     public void testFeedbackListener() {
         final CoreFeedbackDialogModel instance = new CoreFeedbackDialogModel(config,
-                connectionManager,
-                feedbackSenderFactory, path);
+                connectionManager, feedbackSenderFactory, path, clientInfo);
         instance.addListener(listener);
         instance.setFeedback(Optional.ofNullable("DMDirc Rocks."));
         verify(listener).feedbackChanged(Optional.ofNullable("DMDirc Rocks."));
     @Test
     public void testServerInfoListener() {
         final CoreFeedbackDialogModel instance = new CoreFeedbackDialogModel(config,
-                connectionManager,
-                feedbackSenderFactory, path);
+                connectionManager, feedbackSenderFactory, path, clientInfo);
         instance.addListener(listener);
         instance.setIncludeServerInfo(true);
         verify(listener).includeServerInfoChanged(true);
     @Test
     public void testDMDircInfoListener() {
         final CoreFeedbackDialogModel instance = new CoreFeedbackDialogModel(config,
-                connectionManager,
-                feedbackSenderFactory, path);
+                connectionManager, feedbackSenderFactory, path, clientInfo);
         instance.addListener(listener);
         instance.setIncludeDMDircInfo(true);
         verify(listener).includeDMDircInfoChanged(true);