Static imports.

bramble-android/src/main/java/org/briarproject/bramble/account/AndroidAccountManager.java

@@ -17,11 +17,13 @@ import java.util.logging.Logger;
 import javax.annotation.Nullable;
 import javax.inject.Inject;
 
+import static java.util.logging.Logger.getLogger;
+
 class AndroidAccountManager extends AccountManagerImpl
 		implements AccountManager {
 
 	private static final Logger LOG =
-			Logger.getLogger(AndroidAccountManager.class.getName());
+			getLogger(AndroidAccountManager.class.getName());
 
 	private static final String PREF_DB_KEY = "key";
 

bramble-android/src/main/java/org/briarproject/bramble/network/AndroidNetworkManager.java

@@ -37,13 +37,14 @@ import static android.os.PowerManager.ACTION_DEVICE_IDLE_MODE_CHANGED;
 import static java.util.concurrent.TimeUnit.MINUTES;
 import static java.util.concurrent.TimeUnit.SECONDS;
 import static java.util.logging.Level.INFO;
+import static java.util.logging.Logger.getLogger;
 
 @MethodsNotNullByDefault
 @ParametersNotNullByDefault
 class AndroidNetworkManager implements NetworkManager, Service {
 
 	private static final Logger LOG =
-			Logger.getLogger(AndroidNetworkManager.class.getName());
+			getLogger(AndroidNetworkManager.class.getName());
 
 	// See android.net.wifi.WifiManager
 	private static final String WIFI_AP_STATE_CHANGED_ACTION =

bramble-android/src/main/java/org/briarproject/bramble/plugin/bluetooth/AndroidBluetoothPlugin.java

@@ -51,6 +51,7 @@ import static android.bluetooth.BluetoothDevice.EXTRA_DEVICE;
 import static java.util.concurrent.TimeUnit.MILLISECONDS;
 import static java.util.logging.Level.INFO;
 import static java.util.logging.Level.WARNING;
+import static java.util.logging.Logger.getLogger;
 import static org.briarproject.bramble.util.PrivacyUtils.scrubMacAddress;
 
 @MethodsNotNullByDefault
@@ -58,7 +59,7 @@ import static org.briarproject.bramble.util.PrivacyUtils.scrubMacAddress;
 class AndroidBluetoothPlugin extends BluetoothPlugin<BluetoothServerSocket> {
 
 	private static final Logger LOG =
-			Logger.getLogger(AndroidBluetoothPlugin.class.getName());
+			getLogger(AndroidBluetoothPlugin.class.getName());
 
 	private static final int MAX_DISCOVERY_MS = 10_000;
 

bramble-android/src/main/java/org/briarproject/bramble/plugin/tcp/AndroidLanTcpPlugin.java

@@ -32,17 +32,18 @@ import static android.net.ConnectivityManager.TYPE_WIFI;
 import static android.os.Build.VERSION.SDK_INT;
 import static java.util.Collections.emptyList;
 import static java.util.Collections.singletonList;
+import static java.util.logging.Logger.getLogger;
 
 @NotNullByDefault
 class AndroidLanTcpPlugin extends LanTcpPlugin implements EventListener {
 
+	private static final Logger LOG =
+			getLogger(AndroidLanTcpPlugin.class.getName());
+
 	private static final byte[] WIFI_AP_ADDRESS_BYTES =
 			{(byte) 192, (byte) 168, 43, 1};
 	private static final InetAddress WIFI_AP_ADDRESS;
 
-	private static final Logger LOG =
-			Logger.getLogger(AndroidLanTcpPlugin.class.getName());
-
 	static {
 		try {
 			WIFI_AP_ADDRESS = InetAddress.getByAddress(WIFI_AP_ADDRESS_BYTES);

bramble-android/src/main/java/org/briarproject/bramble/plugin/tor/AndroidTorPluginFactory.java

@@ -26,12 +26,14 @@ import java.util.logging.Logger;
 import javax.annotation.concurrent.Immutable;
 import javax.net.SocketFactory;
 
+import static java.util.logging.Logger.getLogger;
+
 @Immutable
 @NotNullByDefault
 public class AndroidTorPluginFactory implements DuplexPluginFactory {
 
 	private static final Logger LOG =
-			Logger.getLogger(AndroidTorPluginFactory.class.getName());
+			getLogger(AndroidTorPluginFactory.class.getName());
 
 	private static final int MAX_LATENCY = 30 * 1000; // 30 seconds
 	private static final int MAX_IDLE_TIME = 30 * 1000; // 30 seconds

bramble-android/src/main/java/org/briarproject/bramble/system/AndroidLocationUtils.java

@@ -15,12 +15,13 @@ import java.util.logging.Logger;
 import javax.inject.Inject;
 
 import static android.content.Context.TELEPHONY_SERVICE;
+import static java.util.logging.Logger.getLogger;
 
 @NotNullByDefault
 class AndroidLocationUtils implements LocationUtils {
 
 	private static final Logger LOG =
-			Logger.getLogger(AndroidLocationUtils.class.getName());
+			getLogger(AndroidLocationUtils.class.getName());
 
 	private final Context appContext;
 

bramble-android/src/main/java/org/briarproject/bramble/util/AndroidUtils.java

@@ -14,6 +14,7 @@ import java.util.List;
 
 import static android.content.Context.MODE_PRIVATE;
 import static android.os.Build.VERSION.SDK_INT;
+import static org.briarproject.bramble.util.StringUtils.isNullOrEmpty;
 
 public class AndroidUtils {
 
@@ -49,7 +50,7 @@ public class AndroidUtils {
 	}
 
 	private static boolean isValidBluetoothAddress(String address) {
-		return !StringUtils.isNullOrEmpty(address)
+		return !isNullOrEmpty(address)
 				&& BluetoothAdapter.checkBluetoothAddress(address)
 				&& !address.equals(FAKE_BLUETOOTH_ADDRESS);
 	}

bramble-android/src/main/java/org/briarproject/bramble/util/RenewableWakeLock.java

@@ -14,13 +14,14 @@ import javax.annotation.concurrent.ThreadSafe;
 
 import static java.util.concurrent.TimeUnit.MILLISECONDS;
 import static java.util.logging.Level.INFO;
+import static java.util.logging.Logger.getLogger;
 
 @ThreadSafe
 @NotNullByDefault
 public class RenewableWakeLock {
 
 	private static final Logger LOG =
-			Logger.getLogger(RenewableWakeLock.class.getName());
+			getLogger(RenewableWakeLock.class.getName());
 
 	/**
 	 * Automatically release the lock this many milliseconds after it's due

bramble-api/src/main/java/org/briarproject/bramble/api/Bytes.java

@@ -1,13 +1,14 @@
 package org.briarproject.bramble.api;
 
 import org.briarproject.bramble.api.nullsafety.NotNullByDefault;
-import org.briarproject.bramble.util.StringUtils;
 
 import java.util.Arrays;
 import java.util.Comparator;
 
 import javax.annotation.concurrent.ThreadSafe;
 
+import static org.briarproject.bramble.util.StringUtils.toHexString;
+
 /**
  * A wrapper around a byte array, to allow it to be stored in maps etc.
  */
@@ -56,8 +57,7 @@ public class Bytes implements Comparable<Bytes> {
 
 	@Override
 	public String toString() {
-		return getClass().getSimpleName() +
+		return getClass().getSimpleName() + "(" + toHexString(getBytes()) + ")";
-				"(" + StringUtils.toHexString(getBytes()) + ")";
 	}
 
 	public static class BytesComparator implements Comparator<Bytes> {

bramble-api/src/main/java/org/briarproject/bramble/api/client/BdfMessageValidator.java

@@ -16,6 +16,7 @@ import java.util.logging.Logger;
 
 import javax.annotation.concurrent.Immutable;
 
+import static java.util.logging.Logger.getLogger;
 import static org.briarproject.bramble.api.transport.TransportConstants.MAX_CLOCK_DIFFERENCE;
 
 @Immutable
@@ -23,7 +24,7 @@ import static org.briarproject.bramble.api.transport.TransportConstants.MAX_CLOC
 public abstract class BdfMessageValidator implements MessageValidator {
 
 	protected static final Logger LOG =
-			Logger.getLogger(BdfMessageValidator.class.getName());
+			getLogger(BdfMessageValidator.class.getName());
 
 	protected final ClientHelper clientHelper;
 	protected final MetadataEncoder metadataEncoder;

bramble-api/src/main/java/org/briarproject/bramble/api/identity/Author.java

@@ -2,12 +2,12 @@ package org.briarproject.bramble.api.identity;
 
 import org.briarproject.bramble.api.Nameable;
 import org.briarproject.bramble.api.nullsafety.NotNullByDefault;
-import org.briarproject.bramble.util.StringUtils;
 
 import javax.annotation.concurrent.Immutable;
 
 import static org.briarproject.bramble.api.identity.AuthorConstants.MAX_AUTHOR_NAME_LENGTH;
 import static org.briarproject.bramble.api.identity.AuthorConstants.MAX_PUBLIC_KEY_LENGTH;
+import static org.briarproject.bramble.util.StringUtils.toUtf8;
 
 /**
  * A pseudonym for a user.
@@ -28,7 +28,7 @@ public class Author implements Nameable {
 
 	public Author(AuthorId id, int formatVersion, String name,
 			byte[] publicKey) {
-		int nameLength = StringUtils.toUtf8(name).length;
+		int nameLength = toUtf8(name).length;
 		if (nameLength == 0 || nameLength > MAX_AUTHOR_NAME_LENGTH)
 			throw new IllegalArgumentException();
 		if (publicKey.length == 0 || publicKey.length > MAX_PUBLIC_KEY_LENGTH)

bramble-api/src/main/java/org/briarproject/bramble/api/plugin/TransportId.java

@@ -1,6 +1,6 @@
 package org.briarproject.bramble.api.plugin;
 
-import org.briarproject.bramble.util.StringUtils;
+import static org.briarproject.bramble.util.StringUtils.toUtf8;
 
 /**
  * Type-safe wrapper for a namespaced string that uniquely identifies a
@@ -16,7 +16,7 @@ public class TransportId {
 	private final String id;
 
 	public TransportId(String id) {
-		int length = StringUtils.toUtf8(id).length;
+		int length = toUtf8(id).length;
 		if (length == 0 || length > MAX_TRANSPORT_ID_LENGTH)
 			throw new IllegalArgumentException();
 		this.id = id;

bramble-api/src/main/java/org/briarproject/bramble/api/sync/ClientId.java

@@ -1,10 +1,11 @@
 package org.briarproject.bramble.api.sync;
 
 import org.briarproject.bramble.api.nullsafety.NotNullByDefault;
-import org.briarproject.bramble.util.StringUtils;
 
 import javax.annotation.concurrent.Immutable;
 
+import static org.briarproject.bramble.util.StringUtils.toUtf8;
+
 /**
  * Type-safe wrapper for a namespaced string that uniquely identifies a sync
  * client.
@@ -21,7 +22,7 @@ public class ClientId implements Comparable<ClientId> {
 	private final String id;
 
 	public ClientId(String id) {
-		int length = StringUtils.toUtf8(id).length;
+		int length = toUtf8(id).length;
 		if (length == 0 || length > MAX_CLIENT_ID_LENGTH)
 			throw new IllegalArgumentException();
 		this.id = id;

bramble-api/src/main/java/org/briarproject/bramble/util/IoUtils.java

@@ -16,12 +16,13 @@ import java.util.logging.Logger;
 import javax.annotation.Nullable;
 
 import static java.util.logging.Level.WARNING;
+import static java.util.logging.Logger.getLogger;
 import static org.briarproject.bramble.util.LogUtils.logException;
 
 @NotNullByDefault
 public class IoUtils {
 
-	private static final Logger LOG = Logger.getLogger(IoUtils.class.getName());
+	private static final Logger LOG = getLogger(IoUtils.class.getName());
 
 	public static void deleteFileOrDir(File f) {
 		if (f.isFile()) {

bramble-api/src/main/java/org/briarproject/bramble/util/ValidationUtils.java

@@ -7,13 +7,15 @@ import org.briarproject.bramble.api.nullsafety.NotNullByDefault;
 
 import javax.annotation.Nullable;
 
+import static org.briarproject.bramble.util.StringUtils.toUtf8;
+
 @NotNullByDefault
 public class ValidationUtils {
 
 	public static void checkLength(@Nullable String s, int minLength,
 			int maxLength) throws FormatException {
 		if (s != null) {
-			int length = StringUtils.toUtf8(s).length;
+			int length = toUtf8(s).length;
 			if (length < minLength) throw new FormatException();
 			if (length > maxLength) throw new FormatException();
 		}
@@ -21,7 +23,7 @@ public class ValidationUtils {
 
 	public static void checkLength(@Nullable String s, int length)
 			throws FormatException {
-		if (s != null && StringUtils.toUtf8(s).length != length)
+		if (s != null && toUtf8(s).length != length)
 			throw new FormatException();
 	}
 

bramble-core/src/main/java/org/briarproject/bramble/PoliteExecutor.java

@@ -10,6 +10,7 @@ import java.util.logging.Logger;
 import javax.annotation.concurrent.GuardedBy;
 
 import static java.util.logging.Level.FINE;
+import static java.util.logging.Logger.getLogger;
 import static org.briarproject.bramble.util.LogUtils.now;
 
 /**
@@ -42,7 +43,7 @@ public class PoliteExecutor implements Executor {
 			int maxConcurrentTasks) {
 		this.delegate = delegate;
 		this.maxConcurrentTasks = maxConcurrentTasks;
-		log = Logger.getLogger(tag);
+		log = getLogger(tag);
 	}
 
 	@Override

bramble-core/src/main/java/org/briarproject/bramble/TimeLoggingExecutor.java

@@ -9,6 +9,7 @@ import java.util.concurrent.TimeUnit;
 import java.util.logging.Logger;
 
 import static java.util.logging.Level.FINE;
+import static java.util.logging.Logger.getLogger;
 import static org.briarproject.bramble.util.LogUtils.now;
 
 @NotNullByDefault
@@ -22,7 +23,7 @@ public class TimeLoggingExecutor extends ThreadPoolExecutor {
 			RejectedExecutionHandler handler) {
 		super(corePoolSize, maxPoolSize, keepAliveTime, unit, workQueue,
 				handler);
-		log = Logger.getLogger(tag);
+		log = getLogger(tag);
 	}
 
 	@Override

bramble-core/src/main/java/org/briarproject/bramble/account/AccountManagerImpl.java

@@ -22,6 +22,7 @@ import javax.annotation.Nullable;
 import javax.inject.Inject;
 
 import static java.util.logging.Level.WARNING;
+import static java.util.logging.Logger.getLogger;
 import static org.briarproject.bramble.util.LogUtils.logException;
 import static org.briarproject.bramble.util.StringUtils.fromHexString;
 import static org.briarproject.bramble.util.StringUtils.toHexString;
@@ -31,7 +32,7 @@ import static org.briarproject.bramble.util.StringUtils.toHexString;
 class AccountManagerImpl implements AccountManager {
 
 	private static final Logger LOG =
-			Logger.getLogger(AccountManagerImpl.class.getName());
+			getLogger(AccountManagerImpl.class.getName());
 
 	private static final String DB_KEY_FILENAME = "db.key";
 	private static final String DB_KEY_BACKUP_FILENAME = "db.key.bak";

bramble-core/src/main/java/org/briarproject/bramble/contact/ContactExchangeTaskImpl.java

@@ -43,6 +43,7 @@ import java.util.logging.Logger;
 import javax.inject.Inject;
 
 import static java.util.logging.Level.WARNING;
+import static java.util.logging.Logger.getLogger;
 import static org.briarproject.bramble.api.contact.RecordTypes.CONTACT_INFO;
 import static org.briarproject.bramble.api.identity.AuthorConstants.MAX_SIGNATURE_LENGTH;
 import static org.briarproject.bramble.util.LogUtils.logException;
@@ -54,7 +55,7 @@ import static org.briarproject.bramble.util.ValidationUtils.checkSize;
 class ContactExchangeTaskImpl extends Thread implements ContactExchangeTask {
 
 	private static final Logger LOG =
-			Logger.getLogger(ContactExchangeTaskImpl.class.getName());
+			getLogger(ContactExchangeTaskImpl.class.getName());
 
 	private static final String SIGNING_LABEL_EXCHANGE =
 			"org.briarproject.briar.contact/EXCHANGE";

bramble-core/src/main/java/org/briarproject/bramble/crypto/AsciiArmour.java

@@ -2,13 +2,15 @@ package org.briarproject.bramble.crypto;
 
 import org.briarproject.bramble.api.FormatException;
 import org.briarproject.bramble.api.nullsafety.NotNullByDefault;
-import org.briarproject.bramble.util.StringUtils;
+
+import static org.briarproject.bramble.util.StringUtils.fromHexString;
+import static org.briarproject.bramble.util.StringUtils.toHexString;
 
 @NotNullByDefault
 class AsciiArmour {
 
 	static String wrap(byte[] b, int lineLength) {
-		String wrapped = StringUtils.toHexString(b);
+		String wrapped = toHexString(b);
 		StringBuilder s = new StringBuilder();
 		int length = wrapped.length();
 		for (int i = 0; i < length; i += lineLength) {
@@ -21,7 +23,7 @@ class AsciiArmour {
 
 	static byte[] unwrap(String s) throws FormatException {
 		try {
-			return StringUtils.fromHexString(s.replaceAll("[^0-9a-fA-F]", ""));
+			return fromHexString(s.replaceAll("[^0-9a-fA-F]", ""));
 		} catch (IllegalArgumentException e) {
 			throw new FormatException();
 		}

bramble-core/src/main/java/org/briarproject/bramble/crypto/CryptoComponentImpl.java

@@ -12,8 +12,6 @@ import org.briarproject.bramble.api.crypto.PublicKey;
 import org.briarproject.bramble.api.crypto.SecretKey;
 import org.briarproject.bramble.api.nullsafety.NotNullByDefault;
 import org.briarproject.bramble.api.system.SecureRandomProvider;
-import org.briarproject.bramble.util.ByteUtils;
-import org.briarproject.bramble.util.StringUtils;
 import org.spongycastle.crypto.CryptoException;
 import org.spongycastle.crypto.Digest;
 import org.spongycastle.crypto.digests.Blake2bDigest;
@@ -31,15 +29,19 @@ import javax.annotation.Nullable;
 import javax.inject.Inject;
 
 import static java.util.logging.Level.INFO;
+import static java.util.logging.Logger.getLogger;
 import static org.briarproject.bramble.util.ByteUtils.INT_32_BYTES;
+import static org.briarproject.bramble.util.ByteUtils.readUint32;
+import static org.briarproject.bramble.util.ByteUtils.writeUint32;
 import static org.briarproject.bramble.util.LogUtils.logDuration;
 import static org.briarproject.bramble.util.LogUtils.now;
+import static org.briarproject.bramble.util.StringUtils.toUtf8;
 
 @NotNullByDefault
 class CryptoComponentImpl implements CryptoComponent {
 
 	private static final Logger LOG =
-			Logger.getLogger(CryptoComponentImpl.class.getName());
+			getLogger(CryptoComponentImpl.class.getName());
 
 	private static final int SIGNATURE_KEY_PAIR_BITS = 256;
 	private static final int STORAGE_IV_BYTES = 24; // 196 bits
@@ -216,26 +218,26 @@ class CryptoComponentImpl implements CryptoComponent {
 
 	private void updateSignature(Signature signature, String label,
 			byte[] toSign) throws GeneralSecurityException {
-		byte[] labelBytes = StringUtils.toUtf8(label);
+		byte[] labelBytes = toUtf8(label);
 		byte[] length = new byte[INT_32_BYTES];
-		ByteUtils.writeUint32(labelBytes.length, length, 0);
+		writeUint32(labelBytes.length, length, 0);
 		signature.update(length);
 		signature.update(labelBytes);
-		ByteUtils.writeUint32(toSign.length, length, 0);
+		writeUint32(toSign.length, length, 0);
 		signature.update(length);
 		signature.update(toSign);
 	}
 
 	@Override
 	public byte[] hash(String label, byte[]... inputs) {
-		byte[] labelBytes = StringUtils.toUtf8(label);
+		byte[] labelBytes = toUtf8(label);
 		Digest digest = new Blake2bDigest(256);
 		byte[] length = new byte[INT_32_BYTES];
-		ByteUtils.writeUint32(labelBytes.length, length, 0);
+		writeUint32(labelBytes.length, length, 0);
 		digest.update(length, 0, length.length);
 		digest.update(labelBytes, 0, labelBytes.length);
 		for (byte[] input : inputs) {
-			ByteUtils.writeUint32(input.length, length, 0);
+			writeUint32(input.length, length, 0);
 			digest.update(length, 0, length.length);
 			digest.update(input, 0, input.length);
 		}
@@ -246,14 +248,14 @@ class CryptoComponentImpl implements CryptoComponent {
 
 	@Override
 	public byte[] mac(String label, SecretKey macKey, byte[]... inputs) {
-		byte[] labelBytes = StringUtils.toUtf8(label);
+		byte[] labelBytes = toUtf8(label);
 		Digest mac = new Blake2bDigest(macKey.getBytes(), 32, null, null);
 		byte[] length = new byte[INT_32_BYTES];
-		ByteUtils.writeUint32(labelBytes.length, length, 0);
+		writeUint32(labelBytes.length, length, 0);
 		mac.update(length, 0, length.length);
 		mac.update(labelBytes, 0, labelBytes.length);
 		for (byte[] input : inputs) {
-			ByteUtils.writeUint32(input.length, length, 0);
+			writeUint32(input.length, length, 0);
 			mac.update(length, 0, length.length);
 			mac.update(input, 0, input.length);
 		}
@@ -300,7 +302,7 @@ class CryptoComponentImpl implements CryptoComponent {
 		System.arraycopy(salt, 0, output, outputOff, salt.length);
 		outputOff += salt.length;
 		// Cost parameter
-		ByteUtils.writeUint32(cost, output, outputOff);
+		writeUint32(cost, output, outputOff);
 		outputOff += INT_32_BYTES;
 		// IV
 		System.arraycopy(iv, 0, output, outputOff, iv.length);
@@ -336,7 +338,7 @@ class CryptoComponentImpl implements CryptoComponent {
 		System.arraycopy(input, inputOff, salt, 0, salt.length);
 		inputOff += salt.length;
 		// Cost parameter
-		long cost = ByteUtils.readUint32(input, inputOff);
+		long cost = readUint32(input, inputOff);
 		inputOff += INT_32_BYTES;
 		if (cost < 2 || cost > Integer.MAX_VALUE)
 			return null; // Invalid cost parameter

bramble-core/src/main/java/org/briarproject/bramble/crypto/FrameEncoder.java

@@ -1,13 +1,15 @@
 package org.briarproject.bramble.crypto;
 
 import org.briarproject.bramble.api.nullsafety.NotNullByDefault;
-import org.briarproject.bramble.util.ByteUtils;
 
 import static org.briarproject.bramble.api.transport.TransportConstants.FRAME_HEADER_PLAINTEXT_LENGTH;
 import static org.briarproject.bramble.api.transport.TransportConstants.FRAME_NONCE_LENGTH;
 import static org.briarproject.bramble.api.transport.TransportConstants.MAX_PAYLOAD_LENGTH;
 import static org.briarproject.bramble.util.ByteUtils.INT_16_BYTES;
 import static org.briarproject.bramble.util.ByteUtils.INT_64_BYTES;
+import static org.briarproject.bramble.util.ByteUtils.readUint16;
+import static org.briarproject.bramble.util.ByteUtils.writeUint16;
+import static org.briarproject.bramble.util.ByteUtils.writeUint64;
 
 @NotNullByDefault
 class FrameEncoder {
@@ -16,7 +18,7 @@ class FrameEncoder {
 		if (dest.length < FRAME_NONCE_LENGTH)
 			throw new IllegalArgumentException();
 		if (frameNumber < 0) throw new IllegalArgumentException();
-		ByteUtils.writeUint64(frameNumber, dest, 0);
+		writeUint64(frameNumber, dest, 0);
 		if (header) dest[0] |= 0x80;
 		for (int i = INT_64_BYTES; i < FRAME_NONCE_LENGTH; i++) dest[i] = 0;
 	}
@@ -29,8 +31,8 @@ class FrameEncoder {
 		if (paddingLength < 0) throw new IllegalArgumentException();
 		if (payloadLength + paddingLength > MAX_PAYLOAD_LENGTH)
 			throw new IllegalArgumentException();
-		ByteUtils.writeUint16(payloadLength, dest, 0);
+		writeUint16(payloadLength, dest, 0);
-		ByteUtils.writeUint16(paddingLength, dest, INT_16_BYTES);
+		writeUint16(paddingLength, dest, INT_16_BYTES);
 		if (finalFrame) dest[0] |= 0x80;
 	}
 
@@ -43,12 +45,12 @@ class FrameEncoder {
 	static int getPayloadLength(byte[] header) {
 		if (header.length < FRAME_HEADER_PLAINTEXT_LENGTH)
 			throw new IllegalArgumentException();
-		return ByteUtils.readUint16(header, 0) & 0x7FFF;
+		return readUint16(header, 0) & 0x7FFF;
 	}
 
 	static int getPaddingLength(byte[] header) {
 		if (header.length < FRAME_HEADER_PLAINTEXT_LENGTH)
 			throw new IllegalArgumentException();
-		return ByteUtils.readUint16(header, INT_16_BYTES);
+		return readUint16(header, INT_16_BYTES);
 	}
 }

bramble-core/src/main/java/org/briarproject/bramble/crypto/MessageEncrypter.java

@@ -5,7 +5,6 @@ import org.briarproject.bramble.api.crypto.KeyParser;
 import org.briarproject.bramble.api.crypto.PrivateKey;
 import org.briarproject.bramble.api.crypto.PublicKey;
 import org.briarproject.bramble.api.nullsafety.NotNullByDefault;
-import org.briarproject.bramble.util.StringUtils;
 import org.spongycastle.asn1.teletrust.TeleTrusTNamedCurves;
 import org.spongycastle.asn1.x9.X9ECParameters;
 import org.spongycastle.crypto.AsymmetricCipherKeyPair;
@@ -45,6 +44,9 @@ import java.util.Scanner;
 
 import javax.annotation.concurrent.Immutable;
 
+import static org.briarproject.bramble.util.StringUtils.fromHexString;
+import static org.briarproject.bramble.util.StringUtils.toHexString;
+
 @Immutable
 @NotNullByDefault
 public class MessageEncrypter {
@@ -210,11 +212,11 @@ public class MessageEncrypter {
 		MessageEncrypter encrypter = new MessageEncrypter(random);
 		KeyPair keyPair = encrypter.generateKeyPair();
 		PrintStream out = new PrintStream(new FileOutputStream(publicKeyFile));
-		out.print(StringUtils.toHexString(keyPair.getPublic().getEncoded()));
+		out.print(toHexString(keyPair.getPublic().getEncoded()));
 		out.flush();
 		out.close();
 		out = new PrintStream(new FileOutputStream(privateKeyFile));
-		out.print(StringUtils.toHexString(keyPair.getPrivate().getEncoded()));
+		out.print(toHexString(keyPair.getPrivate().getEncoded()));
 		out.flush();
 		out.close();
 	}
@@ -223,7 +225,7 @@ public class MessageEncrypter {
 		SecureRandom random = new SecureRandom();
 		MessageEncrypter encrypter = new MessageEncrypter(random);
 		InputStream in = new FileInputStream(publicKeyFile);
-		byte[] keyBytes = StringUtils.fromHexString(readFully(in).trim());
+		byte[] keyBytes = fromHexString(readFully(in).trim());
 		PublicKey publicKey =
 				encrypter.getKeyParser().parsePublicKey(keyBytes);
 		String message = readFully(System.in);
@@ -236,7 +238,7 @@ public class MessageEncrypter {
 		SecureRandom random = new SecureRandom();
 		MessageEncrypter encrypter = new MessageEncrypter(random);
 		InputStream in = new FileInputStream(privateKeyFile);
-		byte[] keyBytes = StringUtils.fromHexString(readFully(in).trim());
+		byte[] keyBytes = fromHexString(readFully(in).trim());
 		PrivateKey privateKey =
 				encrypter.getKeyParser().parsePrivateKey(keyBytes);
 		byte[] ciphertext = AsciiArmour.unwrap(readFully(System.in));

bramble-core/src/main/java/org/briarproject/bramble/crypto/ScryptKdf.java

@@ -2,7 +2,6 @@ package org.briarproject.bramble.crypto;
 
 import org.briarproject.bramble.api.crypto.SecretKey;
 import org.briarproject.bramble.api.system.Clock;
-import org.briarproject.bramble.util.StringUtils;
 import org.spongycastle.crypto.generators.SCrypt;
 
 import java.util.logging.Logger;
@@ -10,13 +9,14 @@ import java.util.logging.Logger;
 import javax.inject.Inject;
 
 import static java.util.logging.Level.INFO;
+import static java.util.logging.Logger.getLogger;
 import static org.briarproject.bramble.util.LogUtils.logDuration;
 import static org.briarproject.bramble.util.LogUtils.now;
+import static org.briarproject.bramble.util.StringUtils.toUtf8;
 
 class ScryptKdf implements PasswordBasedKdf {
 
-	private static final Logger LOG =
+	private static final Logger LOG = getLogger(ScryptKdf.class.getName());
-			Logger.getLogger(ScryptKdf.class.getName());
 
 	private static final int MIN_COST = 256; // Min parameter N
 	private static final int MAX_COST = 1024 * 1024; // Max parameter N
@@ -53,7 +53,7 @@ class ScryptKdf implements PasswordBasedKdf {
 	@Override
 	public SecretKey deriveKey(String password, byte[] salt, int cost) {
 		long start = now();
-		byte[] passwordBytes = StringUtils.toUtf8(password);
+		byte[] passwordBytes = toUtf8(password);
 		SecretKey k = new SecretKey(SCrypt.generate(passwordBytes, salt, cost,
 				BLOCK_SIZE, PARALLELIZATION, SecretKey.LENGTH));
 		logDuration(LOG, "Deriving key from password", start);

bramble-core/src/main/java/org/briarproject/bramble/crypto/Sec1KeyParser.java

@@ -16,6 +16,7 @@ import java.util.logging.Logger;
 
 import javax.annotation.concurrent.Immutable;
 
+import static java.util.logging.Logger.getLogger;
 import static org.briarproject.bramble.util.LogUtils.logDuration;
 import static org.briarproject.bramble.util.LogUtils.now;
 
@@ -28,8 +29,7 @@ import static org.briarproject.bramble.util.LogUtils.now;
 @NotNullByDefault
 class Sec1KeyParser implements KeyParser {
 
-	private static final Logger LOG =
+	private static final Logger LOG = getLogger(Sec1KeyParser.class.getName());
-			Logger.getLogger(Sec1KeyParser.class.getName());
 
 	private final ECDomainParameters params;
 	private final BigInteger modulus;

bramble-core/src/main/java/org/briarproject/bramble/crypto/StreamDecrypterImpl.java

@@ -4,7 +4,6 @@ import org.briarproject.bramble.api.FormatException;
 import org.briarproject.bramble.api.crypto.SecretKey;
 import org.briarproject.bramble.api.crypto.StreamDecrypter;
 import org.briarproject.bramble.api.nullsafety.NotNullByDefault;
-import org.briarproject.bramble.util.ByteUtils;
 
 import java.io.EOFException;
 import java.io.IOException;
@@ -26,6 +25,8 @@ import static org.briarproject.bramble.api.transport.TransportConstants.STREAM_H
 import static org.briarproject.bramble.api.transport.TransportConstants.STREAM_HEADER_PLAINTEXT_LENGTH;
 import static org.briarproject.bramble.util.ByteUtils.INT_16_BYTES;
 import static org.briarproject.bramble.util.ByteUtils.INT_64_BYTES;
+import static org.briarproject.bramble.util.ByteUtils.readUint16;
+import static org.briarproject.bramble.util.ByteUtils.readUint64;
 
 @NotThreadSafe
 @NotNullByDefault
@@ -145,12 +146,11 @@ class StreamDecrypterImpl implements StreamDecrypter {
 			throw new FormatException();
 		}
 		// Check the protocol version
-		int receivedProtocolVersion =
+		int receivedProtocolVersion = readUint16(streamHeaderPlaintext, 0);
-				ByteUtils.readUint16(streamHeaderPlaintext, 0);
 		if (receivedProtocolVersion != PROTOCOL_VERSION)
 			throw new FormatException();
 		// Check the stream number
-		long receivedStreamNumber = ByteUtils.readUint64(streamHeaderPlaintext,
+		long receivedStreamNumber = readUint64(streamHeaderPlaintext,
 				INT_16_BYTES);
 		if (receivedStreamNumber != streamNumber) throw new FormatException();
 		// Extract the frame key

bramble-core/src/main/java/org/briarproject/bramble/crypto/StreamEncrypterImpl.java

@@ -3,7 +3,6 @@ package org.briarproject.bramble.crypto;
 import org.briarproject.bramble.api.crypto.SecretKey;
 import org.briarproject.bramble.api.crypto.StreamEncrypter;
 import org.briarproject.bramble.api.nullsafety.NotNullByDefault;
-import org.briarproject.bramble.util.ByteUtils;
 
 import java.io.IOException;
 import java.io.OutputStream;
@@ -24,6 +23,8 @@ import static org.briarproject.bramble.api.transport.TransportConstants.STREAM_H
 import static org.briarproject.bramble.api.transport.TransportConstants.STREAM_HEADER_PLAINTEXT_LENGTH;
 import static org.briarproject.bramble.util.ByteUtils.INT_16_BYTES;
 import static org.briarproject.bramble.util.ByteUtils.INT_64_BYTES;
+import static org.briarproject.bramble.util.ByteUtils.writeUint16;
+import static org.briarproject.bramble.util.ByteUtils.writeUint64;
 
 @NotThreadSafe
 @NotNullByDefault
@@ -118,9 +119,8 @@ class StreamEncrypterImpl implements StreamEncrypter {
 	private void writeStreamHeader() throws IOException {
 		// The header contains the protocol version, stream number and frame key
 		byte[] streamHeaderPlaintext = new byte[STREAM_HEADER_PLAINTEXT_LENGTH];
-		ByteUtils.writeUint16(PROTOCOL_VERSION, streamHeaderPlaintext, 0);
+		writeUint16(PROTOCOL_VERSION, streamHeaderPlaintext, 0);
-		ByteUtils.writeUint64(streamNumber, streamHeaderPlaintext,
+		writeUint64(streamNumber, streamHeaderPlaintext, INT_16_BYTES);
-				INT_16_BYTES);
 		System.arraycopy(frameKey.getBytes(), 0, streamHeaderPlaintext,
 				INT_16_BYTES + INT_64_BYTES, SecretKey.LENGTH);
 		byte[] streamHeaderCiphertext = new byte[STREAM_HEADER_LENGTH];

bramble-core/src/main/java/org/briarproject/bramble/crypto/TransportCryptoImpl.java

@@ -7,8 +7,6 @@ import org.briarproject.bramble.api.plugin.TransportId;
 import org.briarproject.bramble.api.transport.IncomingKeys;
 import org.briarproject.bramble.api.transport.OutgoingKeys;
 import org.briarproject.bramble.api.transport.TransportKeys;
-import org.briarproject.bramble.util.ByteUtils;
-import org.briarproject.bramble.util.StringUtils;
 import org.spongycastle.crypto.Digest;
 import org.spongycastle.crypto.digests.Blake2bDigest;
 
@@ -24,6 +22,9 @@ import static org.briarproject.bramble.util.ByteUtils.INT_16_BYTES;
 import static org.briarproject.bramble.util.ByteUtils.INT_64_BYTES;
 import static org.briarproject.bramble.util.ByteUtils.MAX_16_BIT_UNSIGNED;
 import static org.briarproject.bramble.util.ByteUtils.MAX_32_BIT_UNSIGNED;
+import static org.briarproject.bramble.util.ByteUtils.writeUint16;
+import static org.briarproject.bramble.util.ByteUtils.writeUint64;
+import static org.briarproject.bramble.util.StringUtils.toUtf8;
 
 class TransportCryptoImpl implements TransportCrypto {
 
@@ -91,21 +92,21 @@ class TransportCryptoImpl implements TransportCrypto {
 
 	private SecretKey rotateKey(SecretKey k, long rotationPeriod) {
 		byte[] period = new byte[INT_64_BYTES];
-		ByteUtils.writeUint64(rotationPeriod, period, 0);
+		writeUint64(rotationPeriod, period, 0);
 		return crypto.deriveKey(ROTATE_LABEL, k, period);
 	}
 
 	private SecretKey deriveTagKey(SecretKey master, TransportId t,
 			boolean alice) {
 		String label = alice ? ALICE_TAG_LABEL : BOB_TAG_LABEL;
-		byte[] id = StringUtils.toUtf8(t.getString());
+		byte[] id = toUtf8(t.getString());
 		return crypto.deriveKey(label, master, id);
 	}
 
 	private SecretKey deriveHeaderKey(SecretKey master, TransportId t,
 			boolean alice) {
 		String label = alice ? ALICE_HEADER_LABEL : BOB_HEADER_LABEL;
-		byte[] id = StringUtils.toUtf8(t.getString());
+		byte[] id = toUtf8(t.getString());
 		return crypto.deriveKey(label, master, id);
 	}
 
@@ -125,10 +126,10 @@ class TransportCryptoImpl implements TransportCrypto {
 		// The input is the protocol version as a 16-bit integer, followed by
 		// the stream number as a 64-bit integer
 		byte[] protocolVersionBytes = new byte[INT_16_BYTES];
-		ByteUtils.writeUint16(protocolVersion, protocolVersionBytes, 0);
+		writeUint16(protocolVersion, protocolVersionBytes, 0);
 		prf.update(protocolVersionBytes, 0, protocolVersionBytes.length);
 		byte[] streamNumberBytes = new byte[INT_64_BYTES];
-		ByteUtils.writeUint64(streamNumber, streamNumberBytes, 0);
+		writeUint64(streamNumber, streamNumberBytes, 0);
 		prf.update(streamNumberBytes, 0, streamNumberBytes.length);
 		byte[] mac = new byte[macLength];
 		prf.doFinal(mac, 0);

bramble-core/src/main/java/org/briarproject/bramble/db/DatabaseComponentImpl.java

@@ -73,6 +73,7 @@ import javax.annotation.concurrent.ThreadSafe;
 import javax.inject.Inject;
 
 import static java.util.logging.Level.WARNING;
+import static java.util.logging.Logger.getLogger;
 import static org.briarproject.bramble.api.sync.Group.Visibility.INVISIBLE;
 import static org.briarproject.bramble.api.sync.Group.Visibility.SHARED;
 import static org.briarproject.bramble.api.sync.validation.MessageState.DELIVERED;
@@ -87,7 +88,7 @@ import static org.briarproject.bramble.util.LogUtils.now;
 class DatabaseComponentImpl<T> implements DatabaseComponent {
 
 	private static final Logger LOG =
-			Logger.getLogger(DatabaseComponentImpl.class.getName());
+			getLogger(DatabaseComponentImpl.class.getName());
 
 	private final Database<T> db;
 	private final Class<T> txnClass;

bramble-core/src/main/java/org/briarproject/bramble/db/H2Database.java

@@ -7,7 +7,6 @@ import org.briarproject.bramble.api.db.MigrationListener;
 import org.briarproject.bramble.api.nullsafety.NotNullByDefault;
 import org.briarproject.bramble.api.sync.MessageFactory;
 import org.briarproject.bramble.api.system.Clock;
-import org.briarproject.bramble.util.StringUtils;
 
 import java.io.File;
 import java.sql.Connection;
@@ -23,6 +22,7 @@ import javax.inject.Inject;
 import static java.util.logging.Level.WARNING;
 import static java.util.logging.Logger.getLogger;
 import static org.briarproject.bramble.db.JdbcUtils.tryToClose;
+import static org.briarproject.bramble.util.StringUtils.toHexString;
 
 /**
  * Contains all the H2-specific code for the database.
@@ -107,7 +107,7 @@ class H2Database extends JdbcDatabase {
 		Properties props = new Properties();
 		props.setProperty("user", "user");
 		// Separate the file password from the user password with a space
-		String hex = StringUtils.toHexString(key.getBytes());
+		String hex = toHexString(key.getBytes());
 		props.put("password", hex + " password");
 		return DriverManager.getConnection(getUrl(), props);
 	}

bramble-core/src/main/java/org/briarproject/bramble/db/HyperSqlDatabase.java

@@ -7,7 +7,6 @@ import org.briarproject.bramble.api.db.MigrationListener;
 import org.briarproject.bramble.api.nullsafety.NotNullByDefault;
 import org.briarproject.bramble.api.sync.MessageFactory;
 import org.briarproject.bramble.api.system.Clock;
-import org.briarproject.bramble.util.StringUtils;
 
 import java.io.File;
 import java.sql.Connection;
@@ -22,6 +21,7 @@ import javax.inject.Inject;
 import static java.util.logging.Level.WARNING;
 import static java.util.logging.Logger.getLogger;
 import static org.briarproject.bramble.db.JdbcUtils.tryToClose;
+import static org.briarproject.bramble.util.StringUtils.toHexString;
 
 /**
  * Contains all the HSQLDB-specific code for the database.
@@ -114,7 +114,7 @@ class HyperSqlDatabase extends JdbcDatabase {
 	protected Connection createConnection() throws SQLException {
 		SecretKey key = this.key;
 		if (key == null) throw new IllegalStateException();
-		String hex = StringUtils.toHexString(key.getBytes());
+		String hex = toHexString(key.getBytes());
 		return DriverManager.getConnection(url + ";crypt_key=" + hex);
 	}
 

bramble-core/src/main/java/org/briarproject/bramble/db/JdbcDatabase.java

@@ -59,6 +59,7 @@ import static java.sql.Types.INTEGER;
 import static java.sql.Types.VARCHAR;
 import static java.util.logging.Level.INFO;
 import static java.util.logging.Level.WARNING;
+import static java.util.logging.Logger.getLogger;
 import static org.briarproject.bramble.api.db.Metadata.REMOVE;
 import static org.briarproject.bramble.api.sync.Group.Visibility.INVISIBLE;
 import static org.briarproject.bramble.api.sync.Group.Visibility.SHARED;
@@ -309,8 +310,7 @@ abstract class JdbcDatabase implements Database<Connection> {
 			"CREATE INDEX IF NOT EXISTS statusesByContactIdTimestamp"
 					+ " ON statuses (contactId, timestamp)";
 
-	private static final Logger LOG =
+	private static final Logger LOG = getLogger(JdbcDatabase.class.getName());
-			Logger.getLogger(JdbcDatabase.class.getName());
 
 	// Different database libraries use different names for certain types
 	private final MessageFactory messageFactory;

bramble-core/src/main/java/org/briarproject/bramble/db/Migration38_39.java

@@ -8,12 +8,12 @@ import java.sql.Statement;
 import java.util.logging.Logger;
 
 import static java.util.logging.Level.WARNING;
+import static java.util.logging.Logger.getLogger;
 import static org.briarproject.bramble.db.JdbcUtils.tryToClose;
 
 class Migration38_39 implements Migration<Connection> {
 
-	private static final Logger LOG =
+	private static final Logger LOG = getLogger(Migration38_39.class.getName());
-			Logger.getLogger(Migration38_39.class.getName());
 
 	@Override
 	public int getStartVersion() {

bramble-core/src/main/java/org/briarproject/bramble/db/Migration39_40.java

@@ -8,12 +8,12 @@ import java.sql.Statement;
 import java.util.logging.Logger;
 
 import static java.util.logging.Level.WARNING;
+import static java.util.logging.Logger.getLogger;
 import static org.briarproject.bramble.db.JdbcUtils.tryToClose;
 
 class Migration39_40 implements Migration<Connection> {
 
-	private static final Logger LOG =
+	private static final Logger LOG = getLogger(Migration39_40.class.getName());
-			Logger.getLogger(Migration39_40.class.getName());
 
 	@Override
 	public int getStartVersion() {

bramble-core/src/main/java/org/briarproject/bramble/identity/AuthorFactoryImpl.java

@@ -7,8 +7,6 @@ import org.briarproject.bramble.api.identity.AuthorId;
 import org.briarproject.bramble.api.identity.LocalAuthor;
 import org.briarproject.bramble.api.nullsafety.NotNullByDefault;
 import org.briarproject.bramble.api.system.Clock;
-import org.briarproject.bramble.util.ByteUtils;
-import org.briarproject.bramble.util.StringUtils;
 
 import javax.annotation.concurrent.Immutable;
 import javax.inject.Inject;
@@ -16,6 +14,8 @@ import javax.inject.Inject;
 import static org.briarproject.bramble.api.identity.Author.FORMAT_VERSION;
 import static org.briarproject.bramble.api.identity.AuthorId.LABEL;
 import static org.briarproject.bramble.util.ByteUtils.INT_32_BYTES;
+import static org.briarproject.bramble.util.ByteUtils.writeUint32;
+import static org.briarproject.bramble.util.StringUtils.toUtf8;
 
 @Immutable
 @NotNullByDefault
@@ -58,8 +58,8 @@ class AuthorFactoryImpl implements AuthorFactory {
 
 	private AuthorId getId(int formatVersion, String name, byte[] publicKey) {
 		byte[] formatVersionBytes = new byte[INT_32_BYTES];
-		ByteUtils.writeUint32(formatVersion, formatVersionBytes, 0);
+		writeUint32(formatVersion, formatVersionBytes, 0);
 		return new AuthorId(crypto.hash(LABEL, formatVersionBytes,
-				StringUtils.toUtf8(name), publicKey));
+				toUtf8(name), publicKey));
 	}
 }

bramble-core/src/main/java/org/briarproject/bramble/identity/IdentityManagerImpl.java

@@ -16,6 +16,7 @@ import javax.annotation.Nullable;
 import javax.annotation.concurrent.ThreadSafe;
 import javax.inject.Inject;
 
+import static java.util.logging.Logger.getLogger;
 import static org.briarproject.bramble.util.LogUtils.logDuration;
 import static org.briarproject.bramble.util.LogUtils.now;
 
@@ -24,7 +25,7 @@ import static org.briarproject.bramble.util.LogUtils.now;
 class IdentityManagerImpl implements IdentityManager {
 
 	private static final Logger LOG =
-			Logger.getLogger(IdentityManagerImpl.class.getName());
+			getLogger(IdentityManagerImpl.class.getName());
 
 	private final DatabaseComponent db;
 	private final CryptoComponent crypto;

bramble-core/src/main/java/org/briarproject/bramble/keyagreement/ConnectionChooserImpl.java

@@ -20,13 +20,14 @@ import javax.annotation.concurrent.ThreadSafe;
 import javax.inject.Inject;
 
 import static java.util.logging.Level.INFO;
+import static java.util.logging.Logger.getLogger;
 
 @NotNullByDefault
 @ThreadSafe
 class ConnectionChooserImpl implements ConnectionChooser {
 
 	private static final Logger LOG =
-			Logger.getLogger(ConnectionChooserImpl.class.getName());
+			getLogger(ConnectionChooserImpl.class.getName());
 
 	private final Clock clock;
 	private final Executor ioExecutor;

bramble-core/src/main/java/org/briarproject/bramble/keyagreement/KeyAgreementConnector.java

@@ -30,6 +30,7 @@ import javax.annotation.Nullable;
 
 import static java.util.logging.Level.INFO;
 import static java.util.logging.Level.WARNING;
+import static java.util.logging.Logger.getLogger;
 import static org.briarproject.bramble.api.keyagreement.KeyAgreementConstants.CONNECTION_TIMEOUT;
 import static org.briarproject.bramble.util.LogUtils.logException;
 
@@ -41,7 +42,7 @@ class KeyAgreementConnector {
 	}
 
 	private static final Logger LOG =
-			Logger.getLogger(KeyAgreementConnector.class.getName());
+			getLogger(KeyAgreementConnector.class.getName());
 
 	private final Callbacks callbacks;
 	private final KeyAgreementCrypto keyAgreementCrypto;

bramble-core/src/main/java/org/briarproject/bramble/keyagreement/KeyAgreementTaskImpl.java

@@ -28,6 +28,7 @@ import java.util.logging.Logger;
 import javax.inject.Inject;
 
 import static java.util.logging.Level.WARNING;
+import static java.util.logging.Logger.getLogger;
 import static org.briarproject.bramble.util.LogUtils.logException;
 
 @MethodsNotNullByDefault
@@ -36,7 +37,7 @@ class KeyAgreementTaskImpl extends Thread implements KeyAgreementTask,
 		KeyAgreementProtocol.Callbacks, KeyAgreementConnector.Callbacks {
 
 	private static final Logger LOG =
-			Logger.getLogger(KeyAgreementTaskImpl.class.getName());
+			getLogger(KeyAgreementTaskImpl.class.getName());
 
 	private final CryptoComponent crypto;
 	private final KeyAgreementCrypto keyAgreementCrypto;

bramble-core/src/main/java/org/briarproject/bramble/keyagreement/KeyAgreementTransport.java

@@ -16,6 +16,7 @@ import java.io.OutputStream;
 import java.util.logging.Logger;
 
 import static java.util.logging.Level.WARNING;
+import static java.util.logging.Logger.getLogger;
 import static org.briarproject.bramble.api.keyagreement.KeyAgreementConstants.PROTOCOL_VERSION;
 import static org.briarproject.bramble.api.keyagreement.RecordTypes.ABORT;
 import static org.briarproject.bramble.api.keyagreement.RecordTypes.CONFIRM;
@@ -29,7 +30,7 @@ import static org.briarproject.bramble.util.LogUtils.logException;
 class KeyAgreementTransport {
 
 	private static final Logger LOG =
-			Logger.getLogger(KeyAgreementTransport.class.getName());
+			getLogger(KeyAgreementTransport.class.getName());
 
 	private final KeyAgreementConnection kac;
 	private final RecordReader reader;

bramble-core/src/main/java/org/briarproject/bramble/lifecycle/LifecycleManagerImpl.java

@@ -28,6 +28,7 @@ import javax.inject.Inject;
 import static java.util.logging.Level.FINE;
 import static java.util.logging.Level.INFO;
 import static java.util.logging.Level.WARNING;
+import static java.util.logging.Logger.getLogger;
 import static org.briarproject.bramble.api.lifecycle.LifecycleManager.LifecycleState.COMPACTING_DATABASE;
 import static org.briarproject.bramble.api.lifecycle.LifecycleManager.LifecycleState.MIGRATING_DATABASE;
 import static org.briarproject.bramble.api.lifecycle.LifecycleManager.LifecycleState.RUNNING;
@@ -49,7 +50,7 @@ import static org.briarproject.bramble.util.LogUtils.now;
 class LifecycleManagerImpl implements LifecycleManager, MigrationListener {
 
 	private static final Logger LOG =
-			Logger.getLogger(LifecycleManagerImpl.class.getName());
+			getLogger(LifecycleManagerImpl.class.getName());
 
 	private final DatabaseComponent db;
 	private final EventBus eventBus;

bramble-core/src/main/java/org/briarproject/bramble/plugin/ConnectionManagerImpl.java

@@ -26,13 +26,14 @@ import java.util.logging.Logger;
 import javax.inject.Inject;
 
 import static java.util.logging.Level.WARNING;
+import static java.util.logging.Logger.getLogger;
 import static org.briarproject.bramble.api.transport.TransportConstants.TAG_LENGTH;
 import static org.briarproject.bramble.util.LogUtils.logException;
 
 class ConnectionManagerImpl implements ConnectionManager {
 
 	private static final Logger LOG =
-			Logger.getLogger(ConnectionManagerImpl.class.getName());
+			getLogger(ConnectionManagerImpl.class.getName());
 
 	private final Executor ioExecutor;
 	private final KeyManager keyManager;

bramble-core/src/main/java/org/briarproject/bramble/plugin/ConnectionRegistryImpl.java

@@ -25,13 +25,14 @@ import javax.annotation.concurrent.ThreadSafe;
 import javax.inject.Inject;
 
 import static java.util.logging.Level.INFO;
+import static java.util.logging.Logger.getLogger;
 
 @ThreadSafe
 @NotNullByDefault
 class ConnectionRegistryImpl implements ConnectionRegistry {
 
 	private static final Logger LOG =
-			Logger.getLogger(ConnectionRegistryImpl.class.getName());
+			getLogger(ConnectionRegistryImpl.class.getName());
 
 	private final EventBus eventBus;
 	private final Lock lock = new ReentrantLock();

bramble-core/src/main/java/org/briarproject/bramble/plugin/PluginManagerImpl.java

@@ -52,6 +52,7 @@ import javax.inject.Inject;
 import static java.util.logging.Level.FINE;
 import static java.util.logging.Level.INFO;
 import static java.util.logging.Level.WARNING;
+import static java.util.logging.Logger.getLogger;
 import static org.briarproject.bramble.util.LogUtils.logDuration;
 import static org.briarproject.bramble.util.LogUtils.logException;
 import static org.briarproject.bramble.util.LogUtils.now;
@@ -61,7 +62,7 @@ import static org.briarproject.bramble.util.LogUtils.now;
 class PluginManagerImpl implements PluginManager, Service {
 
 	private static final Logger LOG =
-			Logger.getLogger(PluginManagerImpl.class.getName());
+			getLogger(PluginManagerImpl.class.getName());
 
 	private final Executor ioExecutor;
 	private final ScheduledExecutorService scheduler;

bramble-core/src/main/java/org/briarproject/bramble/plugin/Poller.java

@@ -41,13 +41,14 @@ import javax.annotation.concurrent.ThreadSafe;
 import static java.util.concurrent.TimeUnit.MILLISECONDS;
 import static java.util.logging.Level.INFO;
 import static java.util.logging.Level.WARNING;
+import static java.util.logging.Logger.getLogger;
 import static org.briarproject.bramble.util.LogUtils.logException;
 
 @ThreadSafe
 @NotNullByDefault
 class Poller implements EventListener {
 
-	private static final Logger LOG = Logger.getLogger(Poller.class.getName());
+	private static final Logger LOG = getLogger(Poller.class.getName());
 
 	private final Executor ioExecutor;
 	private final ScheduledExecutorService scheduler;

bramble-core/src/main/java/org/briarproject/bramble/plugin/bluetooth/BluetoothConnectionLimiterImpl.java

@@ -13,6 +13,7 @@ import javax.annotation.concurrent.ThreadSafe;
 
 import static java.util.logging.Level.INFO;
 import static java.util.logging.Level.WARNING;
+import static java.util.logging.Logger.getLogger;
 import static org.briarproject.bramble.util.LogUtils.logException;
 
 @NotNullByDefault
@@ -20,7 +21,7 @@ import static org.briarproject.bramble.util.LogUtils.logException;
 class BluetoothConnectionLimiterImpl implements BluetoothConnectionLimiter {
 
 	private static final Logger LOG =
-			Logger.getLogger(BluetoothConnectionLimiterImpl.class.getName());
+			getLogger(BluetoothConnectionLimiterImpl.class.getName());
 
 	private final Object lock = new Object();
 	// The following are locking: lock

bramble-core/src/main/java/org/briarproject/bramble/plugin/bluetooth/BluetoothPlugin.java

@@ -37,6 +37,7 @@ import javax.annotation.Nullable;
 
 import static java.util.logging.Level.INFO;
 import static java.util.logging.Level.WARNING;
+import static java.util.logging.Logger.getLogger;
 import static org.briarproject.bramble.api.keyagreement.KeyAgreementConstants.TRANSPORT_ID_BLUETOOTH;
 import static org.briarproject.bramble.api.plugin.BluetoothConstants.ID;
 import static org.briarproject.bramble.api.plugin.BluetoothConstants.PREF_BT_ENABLE;
@@ -54,7 +55,7 @@ import static org.briarproject.bramble.util.StringUtils.macToString;
 abstract class BluetoothPlugin<SS> implements DuplexPlugin, EventListener {
 
 	private static final Logger LOG =
-			Logger.getLogger(BluetoothPlugin.class.getName());
+			getLogger(BluetoothPlugin.class.getName());
 
 	final BluetoothConnectionLimiter connectionLimiter;
 

bramble-core/src/main/java/org/briarproject/bramble/plugin/file/FilePlugin.java

@@ -14,6 +14,7 @@ import java.io.IOException;
 import java.util.logging.Logger;
 
 import static java.util.logging.Level.WARNING;
+import static java.util.logging.Logger.getLogger;
 import static org.briarproject.bramble.api.plugin.FileConstants.PROP_PATH;
 import static org.briarproject.bramble.util.LogUtils.logException;
 import static org.briarproject.bramble.util.StringUtils.isNullOrEmpty;
@@ -21,8 +22,7 @@ import static org.briarproject.bramble.util.StringUtils.isNullOrEmpty;
 @NotNullByDefault
 abstract class FilePlugin implements SimplexPlugin {
 
-	private static final Logger LOG =
+	private static final Logger LOG = getLogger(FilePlugin.class.getName());
-			Logger.getLogger(FilePlugin.class.getName());
 
 	protected final SimplexPluginCallback callback;
 	protected final int maxLatency;

bramble-core/src/main/java/org/briarproject/bramble/plugin/file/FileTransportReader.java

@@ -8,13 +8,14 @@ import java.io.InputStream;
 import java.util.logging.Logger;
 
 import static java.util.logging.Level.WARNING;
+import static java.util.logging.Logger.getLogger;
 import static org.briarproject.bramble.util.IoUtils.tryToClose;
 
 @NotNullByDefault
 class FileTransportReader implements TransportConnectionReader {
 
 	private static final Logger LOG =
-			Logger.getLogger(FileTransportReader.class.getName());
+			getLogger(FileTransportReader.class.getName());
 
 	private final File file;
 	private final InputStream in;

bramble-core/src/main/java/org/briarproject/bramble/plugin/file/FileTransportWriter.java

@@ -8,13 +8,14 @@ import java.io.OutputStream;
 import java.util.logging.Logger;
 
 import static java.util.logging.Level.WARNING;
+import static java.util.logging.Logger.getLogger;
 import static org.briarproject.bramble.util.IoUtils.tryToClose;
 
 @NotNullByDefault
 class FileTransportWriter implements TransportConnectionWriter {
 
 	private static final Logger LOG =
-			Logger.getLogger(FileTransportWriter.class.getName());
+			getLogger(FileTransportWriter.class.getName());
 
 	private final File file;
 	private final OutputStream out;

bramble-core/src/main/java/org/briarproject/bramble/plugin/tcp/LanTcpPlugin.java

@@ -12,7 +12,6 @@ import org.briarproject.bramble.api.plugin.duplex.DuplexTransportConnection;
 import org.briarproject.bramble.api.properties.TransportProperties;
 import org.briarproject.bramble.api.settings.Settings;
 import org.briarproject.bramble.util.IoUtils;
-import org.briarproject.bramble.util.StringUtils;
 
 import java.io.IOException;
 import java.net.Inet4Address;
@@ -23,26 +22,30 @@ import java.net.Socket;
 import java.net.SocketAddress;
 import java.net.UnknownHostException;
 import java.util.ArrayList;
-import java.util.Collections;
 import java.util.Comparator;
 import java.util.List;
 import java.util.concurrent.Executor;
 import java.util.logging.Logger;
 
+import static java.util.Collections.addAll;
+import static java.util.Collections.emptyList;
+import static java.util.Collections.sort;
 import static java.util.logging.Level.INFO;
 import static java.util.logging.Level.WARNING;
+import static java.util.logging.Logger.getLogger;
 import static org.briarproject.bramble.api.keyagreement.KeyAgreementConstants.TRANSPORT_ID_LAN;
 import static org.briarproject.bramble.api.plugin.LanTcpConstants.ID;
 import static org.briarproject.bramble.api.plugin.LanTcpConstants.PREF_LAN_IP_PORTS;
 import static org.briarproject.bramble.api.plugin.LanTcpConstants.PROP_IP_PORTS;
 import static org.briarproject.bramble.util.ByteUtils.MAX_16_BIT_UNSIGNED;
 import static org.briarproject.bramble.util.PrivacyUtils.scrubSocketAddress;
+import static org.briarproject.bramble.util.StringUtils.isNullOrEmpty;
+import static org.briarproject.bramble.util.StringUtils.join;
 
 @NotNullByDefault
 class LanTcpPlugin extends TcpPlugin {
 
-	private static final Logger LOG =
+	private static final Logger LOG = getLogger(LanTcpPlugin.class.getName());
-			Logger.getLogger(LanTcpPlugin.class.getName());
 
 	private static final LanAddressComparator ADDRESS_COMPARATOR =
 			new LanAddressComparator();
@@ -77,12 +80,12 @@ class LanTcpPlugin extends TcpPlugin {
 				locals.add(new InetSocketAddress(local, 0));
 			}
 		}
-		Collections.sort(locals, ADDRESS_COMPARATOR);
+		sort(locals, ADDRESS_COMPARATOR);
 		return locals;
 	}
 
 	private List<InetSocketAddress> parseSocketAddresses(String ipPorts) {
-		if (StringUtils.isNullOrEmpty(ipPorts)) return Collections.emptyList();
+		if (isNullOrEmpty(ipPorts)) return emptyList();
 		String[] split = ipPorts.split(SEPARATOR);
 		List<InetSocketAddress> addresses = new ArrayList<>();
 		for (String ipPort : split) {
@@ -98,24 +101,23 @@ class LanTcpPlugin extends TcpPlugin {
 		// Get the list of recently used addresses
 		String setting = callback.getSettings().get(PREF_LAN_IP_PORTS);
 		List<String> recent = new ArrayList<>();
-		if (!StringUtils.isNullOrEmpty(setting))
+		if (!isNullOrEmpty(setting)) addAll(recent, setting.split(SEPARATOR));
-			Collections.addAll(recent, setting.split(SEPARATOR));
 		// Is the address already in the list?
 		if (recent.remove(ipPort)) {
 			// Move the address to the start of the list
 			recent.add(0, ipPort);
-			setting = StringUtils.join(recent, SEPARATOR);
+			setting = join(recent, SEPARATOR);
 		} else {
 			// Add the address to the start of the list
 			recent.add(0, ipPort);
 			// Drop the least recently used address if the list is full
 			if (recent.size() > MAX_ADDRESSES)
 				recent = recent.subList(0, MAX_ADDRESSES);
-			setting = StringUtils.join(recent, SEPARATOR);
+			setting = join(recent, SEPARATOR);
 			// Update the list of addresses shared with contacts
 			List<String> shared = new ArrayList<>(recent);
-			Collections.sort(shared);
+			sort(shared);
-			String property = StringUtils.join(shared, SEPARATOR);
+			String property = join(shared, SEPARATOR);
 			TransportProperties properties = new TransportProperties();
 			properties.put(PROP_IP_PORTS, property);
 			callback.mergeLocalProperties(properties);

bramble-core/src/main/java/org/briarproject/bramble/plugin/tcp/PortMapperImpl.java

@@ -17,6 +17,7 @@ import javax.xml.parsers.ParserConfigurationException;
 
 import static java.util.logging.Level.INFO;
 import static java.util.logging.Level.WARNING;
+import static java.util.logging.Logger.getLogger;
 import static org.briarproject.bramble.util.LogUtils.logException;
 import static org.briarproject.bramble.util.PrivacyUtils.scrubInetAddress;
 
@@ -25,8 +26,7 @@ import static org.briarproject.bramble.util.PrivacyUtils.scrubInetAddress;
 @ParametersNotNullByDefault
 class PortMapperImpl implements PortMapper {
 
-	private static final Logger LOG =
+	private static final Logger LOG = getLogger(PortMapperImpl.class.getName());
-			Logger.getLogger(PortMapperImpl.class.getName());
 
 	private final ShutdownManager shutdownManager;
 	private final AtomicBoolean started = new AtomicBoolean(false);

bramble-core/src/main/java/org/briarproject/bramble/plugin/tcp/TcpPlugin.java

@@ -12,7 +12,6 @@ import org.briarproject.bramble.api.plugin.duplex.DuplexPluginCallback;
 import org.briarproject.bramble.api.plugin.duplex.DuplexTransportConnection;
 import org.briarproject.bramble.api.properties.TransportProperties;
 import org.briarproject.bramble.util.IoUtils;
-import org.briarproject.bramble.util.StringUtils;
 
 import java.io.IOException;
 import java.net.InetAddress;
@@ -41,17 +40,19 @@ import static java.util.Collections.emptyList;
 import static java.util.Collections.list;
 import static java.util.logging.Level.INFO;
 import static java.util.logging.Level.WARNING;
+import static java.util.logging.Logger.getLogger;
 import static org.briarproject.bramble.util.LogUtils.logException;
 import static org.briarproject.bramble.util.PrivacyUtils.scrubSocketAddress;
+import static org.briarproject.bramble.util.StringUtils.isNullOrEmpty;
 
 @MethodsNotNullByDefault
 @ParametersNotNullByDefault
 abstract class TcpPlugin implements DuplexPlugin {
 
+	private static final Logger LOG = getLogger(TcpPlugin.class.getName());
+
 	private static final Pattern DOTTED_QUAD =
 			Pattern.compile("^\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}$");
-	private static final Logger LOG =
-			Logger.getLogger(TcpPlugin.class.getName());
 
 	protected final Executor ioExecutor, bindExecutor;
 	protected final Backoff backoff;
@@ -263,7 +264,7 @@ abstract class TcpPlugin implements DuplexPlugin {
 
 	@Nullable
 	InetSocketAddress parseSocketAddress(String ipPort) {
-		if (StringUtils.isNullOrEmpty(ipPort)) return null;
+		if (isNullOrEmpty(ipPort)) return null;
 		String[] split = ipPort.split(":");
 		if (split.length != 2) return null;
 		String addr = split[0], port = split[1];

bramble-core/src/main/java/org/briarproject/bramble/plugin/tor/TorPlugin.java

@@ -60,6 +60,7 @@ import javax.net.SocketFactory;
 
 import static java.util.logging.Level.INFO;
 import static java.util.logging.Level.WARNING;
+import static java.util.logging.Logger.getLogger;
 import static net.freehaven.tor.control.TorControlCommands.HS_ADDRESS;
 import static net.freehaven.tor.control.TorControlCommands.HS_PRIVKEY;
 import static org.briarproject.bramble.api.plugin.TorConstants.CONTROL_PORT;
@@ -73,6 +74,7 @@ import static org.briarproject.bramble.api.plugin.TorConstants.PREF_TOR_ONLY_WHE
 import static org.briarproject.bramble.api.plugin.TorConstants.PREF_TOR_PORT;
 import static org.briarproject.bramble.api.plugin.TorConstants.PROP_ONION_V2;
 import static org.briarproject.bramble.api.plugin.TorConstants.PROP_ONION_V3;
+import static org.briarproject.bramble.util.IoUtils.copyAndClose;
 import static org.briarproject.bramble.util.LogUtils.logException;
 import static org.briarproject.bramble.util.PrivacyUtils.scrubOnion;
 import static org.briarproject.bramble.util.StringUtils.isNullOrEmpty;
@@ -81,8 +83,7 @@ import static org.briarproject.bramble.util.StringUtils.isNullOrEmpty;
 @ParametersNotNullByDefault
 abstract class TorPlugin implements DuplexPlugin, EventHandler, EventListener {
 
-	private static final Logger LOG =
+	private static final Logger LOG = getLogger(TorPlugin.class.getName());
-			Logger.getLogger(TorPlugin.class.getName());
 
 	private static final String[] EVENTS = {
 			"CIRC", "ORCONN", "HS_DESC", "NOTICE", "WARN", "ERR"
@@ -284,23 +285,23 @@ abstract class TorPlugin implements DuplexPlugin, EventHandler, EventListener {
 			// Unzip the Tor binary to the filesystem
 			in = getTorInputStream();
 			out = new FileOutputStream(torFile);
-			IoUtils.copyAndClose(in, out);
+			copyAndClose(in, out);
 			// Make the Tor binary executable
 			if (!torFile.setExecutable(true, true)) throw new IOException();
 			// Unzip the GeoIP database to the filesystem
 			in = getGeoIpInputStream();
 			out = new FileOutputStream(geoIpFile);
-			IoUtils.copyAndClose(in, out);
+			copyAndClose(in, out);
 			// Unzip the Obfs4 proxy to the filesystem
 			in = getObfs4InputStream();
 			out = new FileOutputStream(obfs4File);
-			IoUtils.copyAndClose(in, out);
+			copyAndClose(in, out);
 			// Make the Obfs4 proxy executable
 			if (!obfs4File.setExecutable(true, true)) throw new IOException();
 			// Copy the config file to the filesystem
 			in = getConfigInputStream();
 			out = new FileOutputStream(configFile);
-			IoUtils.copyAndClose(in, out);
+			copyAndClose(in, out);
 			doneFile.createNewFile();
 		} catch (IOException e) {
 			IoUtils.tryToClose(in, LOG, WARNING);

bramble-core/src/main/java/org/briarproject/bramble/record/RecordReaderImpl.java

@@ -4,7 +4,6 @@ import org.briarproject.bramble.api.FormatException;
 import org.briarproject.bramble.api.nullsafety.NotNullByDefault;
 import org.briarproject.bramble.api.record.Record;
 import org.briarproject.bramble.api.record.RecordReader;
-import org.briarproject.bramble.util.ByteUtils;
 
 import java.io.DataInputStream;
 import java.io.IOException;
@@ -14,6 +13,7 @@ import javax.annotation.concurrent.NotThreadSafe;
 
 import static org.briarproject.bramble.api.record.Record.MAX_RECORD_PAYLOAD_BYTES;
 import static org.briarproject.bramble.api.record.Record.RECORD_HEADER_BYTES;
+import static org.briarproject.bramble.util.ByteUtils.readUint16;
 
 @NotThreadSafe
 @NotNullByDefault
@@ -31,7 +31,7 @@ class RecordReaderImpl implements RecordReader {
 		in.readFully(header);
 		byte protocolVersion = header[0];
 		byte recordType = header[1];
-		int payloadLength = ByteUtils.readUint16(header, 2);
+		int payloadLength = readUint16(header, 2);
 		if (payloadLength < 0 || payloadLength > MAX_RECORD_PAYLOAD_BYTES)
 			throw new FormatException();
 		byte[] payload = new byte[payloadLength];

bramble-core/src/main/java/org/briarproject/bramble/record/RecordWriterImpl.java

@@ -3,7 +3,6 @@ package org.briarproject.bramble.record;
 import org.briarproject.bramble.api.nullsafety.NotNullByDefault;
 import org.briarproject.bramble.api.record.Record;
 import org.briarproject.bramble.api.record.RecordWriter;
-import org.briarproject.bramble.util.ByteUtils;
 
 import java.io.IOException;
 import java.io.OutputStream;
@@ -11,6 +10,7 @@ import java.io.OutputStream;
 import javax.annotation.concurrent.NotThreadSafe;
 
 import static org.briarproject.bramble.api.record.Record.RECORD_HEADER_BYTES;
+import static org.briarproject.bramble.util.ByteUtils.writeUint16;
 
 @NotThreadSafe
 @NotNullByDefault
@@ -28,7 +28,7 @@ class RecordWriterImpl implements RecordWriter {
 		byte[] payload = r.getPayload();
 		header[0] = r.getProtocolVersion();
 		header[1] = r.getRecordType();
-		ByteUtils.writeUint16(payload.length, header, 2);
+		writeUint16(payload.length, header, 2);
 		out.write(header);
 		out.write(payload);
 	}

bramble-core/src/main/java/org/briarproject/bramble/reliability/Ack.java

@@ -1,10 +1,12 @@
 package org.briarproject.bramble.reliability;
 
 import org.briarproject.bramble.api.nullsafety.NotNullByDefault;
-import org.briarproject.bramble.util.ByteUtils;
 
 import javax.annotation.concurrent.NotThreadSafe;
 
+import static org.briarproject.bramble.util.ByteUtils.readUint16;
+import static org.briarproject.bramble.util.ByteUtils.writeUint16;
+
 @NotThreadSafe
 @NotNullByDefault
 class Ack extends Frame {
@@ -23,10 +25,10 @@ class Ack extends Frame {
 	}
 
 	int getWindowSize() {
-		return ByteUtils.readUint16(buf, 5);
+		return readUint16(buf, 5);
 	}
 
 	void setWindowSize(int windowSize) {
-		ByteUtils.writeUint16(windowSize, buf, 5);
+		writeUint16(windowSize, buf, 5);
 	}
 }

bramble-core/src/main/java/org/briarproject/bramble/reliability/Frame.java

@@ -1,10 +1,12 @@
 package org.briarproject.bramble.reliability;
 
 import org.briarproject.bramble.api.nullsafety.NotNullByDefault;
-import org.briarproject.bramble.util.ByteUtils;
 
 import javax.annotation.concurrent.NotThreadSafe;
 
+import static org.briarproject.bramble.util.ByteUtils.readUint32;
+import static org.briarproject.bramble.util.ByteUtils.writeUint32;
+
 @NotThreadSafe
 @NotNullByDefault
 abstract class Frame {
@@ -26,11 +28,11 @@ abstract class Frame {
 	}
 
 	long getChecksum() {
-		return ByteUtils.readUint32(buf, buf.length - 4);
+		return readUint32(buf, buf.length - 4);
 	}
 
 	void setChecksum(long checksum) {
-		ByteUtils.writeUint32(checksum, buf, buf.length - 4);
+		writeUint32(checksum, buf, buf.length - 4);
 	}
 
 	long calculateChecksum() {
@@ -38,11 +40,11 @@ abstract class Frame {
 	}
 
 	long getSequenceNumber() {
-		return ByteUtils.readUint32(buf, 1);
+		return readUint32(buf, 1);
 	}
 
 	void setSequenceNumber(long sequenceNumber) {
-		ByteUtils.writeUint32(sequenceNumber, buf, 1);
+		writeUint32(sequenceNumber, buf, 1);
 	}
 
 	@Override

bramble-core/src/main/java/org/briarproject/bramble/reliability/ReliabilityLayerImpl.java

@@ -16,6 +16,7 @@ import java.util.logging.Logger;
 
 import static java.util.concurrent.TimeUnit.MILLISECONDS;
 import static java.util.logging.Level.WARNING;
+import static java.util.logging.Logger.getLogger;
 import static org.briarproject.bramble.util.LogUtils.logException;
 
 @MethodsNotNullByDefault
@@ -25,7 +26,7 @@ class ReliabilityLayerImpl implements ReliabilityLayer, WriteHandler {
 	private static final int TICK_INTERVAL = 500; // Milliseconds
 
 	private static final Logger LOG =
-			Logger.getLogger(ReliabilityLayerImpl.class.getName());
+			getLogger(ReliabilityLayerImpl.class.getName());
 
 	private final Executor executor;
 	private final Clock clock;

bramble-core/src/main/java/org/briarproject/bramble/reporting/DevReporterImpl.java

@@ -9,8 +9,6 @@ import org.briarproject.bramble.api.plugin.TorConstants;
 import org.briarproject.bramble.api.plugin.event.TransportEnabledEvent;
 import org.briarproject.bramble.api.reporting.DevConfig;
 import org.briarproject.bramble.api.reporting.DevReporter;
-import org.briarproject.bramble.util.IoUtils;
-import org.briarproject.bramble.util.StringUtils;
 
 import java.io.File;
 import java.io.FileInputStream;
@@ -30,14 +28,18 @@ import javax.inject.Inject;
 import javax.net.SocketFactory;
 
 import static java.util.logging.Level.WARNING;
+import static java.util.logging.Logger.getLogger;
+import static org.briarproject.bramble.util.IoUtils.copyAndClose;
+import static org.briarproject.bramble.util.IoUtils.getOutputStream;
 import static org.briarproject.bramble.util.IoUtils.tryToClose;
+import static org.briarproject.bramble.util.StringUtils.toUtf8;
 
 @Immutable
 @NotNullByDefault
 class DevReporterImpl implements DevReporter, EventListener {
 
 	private static final Logger LOG =
-			Logger.getLogger(DevReporterImpl.class.getName());
+			getLogger(DevReporterImpl.class.getName());
 
 	private static final int SOCKET_TIMEOUT = 30 * 1000; // 30 seconds
 	private static final int LINE_LENGTH = 70;
@@ -73,7 +75,7 @@ class DevReporterImpl implements DevReporter, EventListener {
 	public void encryptReportToFile(File reportDir, String filename,
 			String report) throws FileNotFoundException {
 		LOG.info("Encrypting report to file");
-		byte[] plaintext = StringUtils.toUtf8(report);
+		byte[] plaintext = toUtf8(report);
 		byte[] ciphertext = crypto.encryptToKey(devConfig.getDevPublicKey(),
 				plaintext);
 		String armoured = crypto.asciiArmour(ciphertext, LINE_LENGTH);
@@ -112,9 +114,9 @@ class DevReporterImpl implements DevReporter, EventListener {
 			InputStream in = null;
 			try {
 				Socket s = connectToDevelopers();
-				out = IoUtils.getOutputStream(s);
+				out = getOutputStream(s);
 				in = new FileInputStream(f);
-				IoUtils.copyAndClose(in, out);
+				copyAndClose(in, out);
 				f.delete();
 			} catch (IOException e) {
 				LOG.log(WARNING, "Failed to send reports", e);

bramble-core/src/main/java/org/briarproject/bramble/socks/SocksSocket.java

@@ -1,6 +1,5 @@
 package org.briarproject.bramble.socks;
 
-import org.briarproject.bramble.util.ByteUtils;
 import org.briarproject.bramble.util.IoUtils;
 
 import java.io.IOException;
@@ -12,6 +11,8 @@ import java.net.Socket;
 import java.net.SocketAddress;
 import java.util.Arrays;
 
+import static org.briarproject.bramble.util.ByteUtils.writeUint16;
+
 class SocksSocket extends Socket {
 
 	private static final String[] ERRORS = {
@@ -108,7 +109,7 @@ class SocksSocket extends Socket {
 		connectRequest[4] = (byte) host.length(); // Length of domain name
 		for (int i = 0; i < host.length(); i++)
 			connectRequest[5 + i] = (byte) host.charAt(i);
-		ByteUtils.writeUint16(port, connectRequest, connectRequest.length - 2);
+		writeUint16(port, connectRequest, connectRequest.length - 2);
 		out.write(connectRequest);
 		out.flush();
 	}

bramble-core/src/main/java/org/briarproject/bramble/sync/DuplexOutgoingSession.java

@@ -39,6 +39,7 @@ import javax.annotation.concurrent.ThreadSafe;
 import static java.util.concurrent.TimeUnit.MILLISECONDS;
 import static java.util.logging.Level.INFO;
 import static java.util.logging.Level.WARNING;
+import static java.util.logging.Logger.getLogger;
 import static org.briarproject.bramble.api.lifecycle.LifecycleManager.LifecycleState.STOPPING;
 import static org.briarproject.bramble.api.record.Record.MAX_RECORD_PAYLOAD_BYTES;
 import static org.briarproject.bramble.api.sync.SyncConstants.MAX_MESSAGE_IDS;
@@ -55,7 +56,7 @@ import static org.briarproject.bramble.util.LogUtils.logException;
 class DuplexOutgoingSession implements SyncSession, EventListener {
 
 	private static final Logger LOG =
-			Logger.getLogger(DuplexOutgoingSession.class.getName());
+			getLogger(DuplexOutgoingSession.class.getName());
 
 	private static final ThrowingRunnable<IOException> CLOSE = () -> {
 	};

bramble-core/src/main/java/org/briarproject/bramble/sync/GroupFactoryImpl.java

@@ -6,8 +6,6 @@ import org.briarproject.bramble.api.sync.ClientId;
 import org.briarproject.bramble.api.sync.Group;
 import org.briarproject.bramble.api.sync.GroupFactory;
 import org.briarproject.bramble.api.sync.GroupId;
-import org.briarproject.bramble.util.ByteUtils;
-import org.briarproject.bramble.util.StringUtils;
 
 import javax.annotation.concurrent.Immutable;
 import javax.inject.Inject;
@@ -15,6 +13,8 @@ import javax.inject.Inject;
 import static org.briarproject.bramble.api.sync.Group.FORMAT_VERSION;
 import static org.briarproject.bramble.api.sync.GroupId.LABEL;
 import static org.briarproject.bramble.util.ByteUtils.INT_32_BYTES;
+import static org.briarproject.bramble.util.ByteUtils.writeUint32;
+import static org.briarproject.bramble.util.StringUtils.toUtf8;
 
 @Immutable
 @NotNullByDefault
@@ -33,10 +33,9 @@ class GroupFactoryImpl implements GroupFactory {
 	@Override
 	public Group createGroup(ClientId c, int majorVersion, byte[] descriptor) {
 		byte[] majorVersionBytes = new byte[INT_32_BYTES];
-		ByteUtils.writeUint32(majorVersion, majorVersionBytes, 0);
+		writeUint32(majorVersion, majorVersionBytes, 0);
 		byte[] hash = crypto.hash(LABEL, FORMAT_VERSION_BYTES,
-				StringUtils.toUtf8(c.getString()), majorVersionBytes,
+				toUtf8(c.getString()), majorVersionBytes, descriptor);
-				descriptor);
 		return new Group(new GroupId(hash), c, majorVersion, descriptor);
 	}
 }

bramble-core/src/main/java/org/briarproject/bramble/sync/IncomingSession.java

@@ -26,6 +26,7 @@ import java.util.logging.Logger;
 import javax.annotation.concurrent.ThreadSafe;
 
 import static java.util.logging.Level.WARNING;
+import static java.util.logging.Logger.getLogger;
 import static org.briarproject.bramble.api.lifecycle.LifecycleManager.LifecycleState.STOPPING;
 import static org.briarproject.bramble.util.LogUtils.logException;
 
@@ -37,7 +38,7 @@ import static org.briarproject.bramble.util.LogUtils.logException;
 class IncomingSession implements SyncSession, EventListener {
 
 	private static final Logger LOG =
-			Logger.getLogger(IncomingSession.class.getName());
+			getLogger(IncomingSession.class.getName());
 
 	private final DatabaseComponent db;
 	private final Executor dbExecutor;

bramble-core/src/main/java/org/briarproject/bramble/sync/MessageFactoryImpl.java

@@ -7,7 +7,6 @@ import org.briarproject.bramble.api.sync.GroupId;
 import org.briarproject.bramble.api.sync.Message;
 import org.briarproject.bramble.api.sync.MessageFactory;
 import org.briarproject.bramble.api.sync.MessageId;
-import org.briarproject.bramble.util.ByteUtils;
 
 import javax.annotation.concurrent.Immutable;
 import javax.inject.Inject;
@@ -19,6 +18,8 @@ import static org.briarproject.bramble.api.sync.SyncConstants.MAX_MESSAGE_BODY_L
 import static org.briarproject.bramble.api.sync.SyncConstants.MAX_MESSAGE_LENGTH;
 import static org.briarproject.bramble.api.sync.SyncConstants.MESSAGE_HEADER_LENGTH;
 import static org.briarproject.bramble.util.ByteUtils.INT_64_BYTES;
+import static org.briarproject.bramble.util.ByteUtils.readUint64;
+import static org.briarproject.bramble.util.ByteUtils.writeUint64;
 
 @Immutable
 @NotNullByDefault
@@ -47,7 +48,7 @@ class MessageFactoryImpl implements MessageFactory {
 		// There's only one block, so the root hash is the hash of the block
 		byte[] rootHash = crypto.hash(BLOCK_LABEL, FORMAT_VERSION_BYTES, body);
 		byte[] timeBytes = new byte[INT_64_BYTES];
-		ByteUtils.writeUint64(timestamp, timeBytes, 0);
+		writeUint64(timestamp, timeBytes, 0);
 		byte[] idHash = crypto.hash(ID_LABEL, FORMAT_VERSION_BYTES,
 				g.getBytes(), timeBytes, rootHash);
 		return new MessageId(idHash);
@@ -62,7 +63,7 @@ class MessageFactoryImpl implements MessageFactory {
 		byte[] groupId = new byte[UniqueId.LENGTH];
 		System.arraycopy(raw, 0, groupId, 0, UniqueId.LENGTH);
 		GroupId g = new GroupId(groupId);
-		long timestamp = ByteUtils.readUint64(raw, UniqueId.LENGTH);
+		long timestamp = readUint64(raw, UniqueId.LENGTH);
 		byte[] body = new byte[raw.length - MESSAGE_HEADER_LENGTH];
 		System.arraycopy(raw, MESSAGE_HEADER_LENGTH, body, 0, body.length);
 		MessageId id = getMessageId(g, timestamp, body);
@@ -74,7 +75,7 @@ class MessageFactoryImpl implements MessageFactory {
 		byte[] body = m.getBody();
 		byte[] raw = new byte[MESSAGE_HEADER_LENGTH + body.length];
 		System.arraycopy(m.getGroupId().getBytes(), 0, raw, 0, UniqueId.LENGTH);
-		ByteUtils.writeUint64(m.getTimestamp(), raw, UniqueId.LENGTH);
+		writeUint64(m.getTimestamp(), raw, UniqueId.LENGTH);
 		System.arraycopy(body, 0, raw, MESSAGE_HEADER_LENGTH, body.length);
 		return raw;
 	}

bramble-core/src/main/java/org/briarproject/bramble/sync/SimplexOutgoingSession.java

@@ -29,6 +29,7 @@ import javax.annotation.concurrent.ThreadSafe;
 
 import static java.util.logging.Level.INFO;
 import static java.util.logging.Level.WARNING;
+import static java.util.logging.Logger.getLogger;
 import static org.briarproject.bramble.api.lifecycle.LifecycleManager.LifecycleState.STOPPING;
 import static org.briarproject.bramble.api.record.Record.MAX_RECORD_PAYLOAD_BYTES;
 import static org.briarproject.bramble.api.sync.SyncConstants.MAX_MESSAGE_IDS;
@@ -44,7 +45,7 @@ import static org.briarproject.bramble.util.LogUtils.logException;
 class SimplexOutgoingSession implements SyncSession, EventListener {
 
 	private static final Logger LOG =
-			Logger.getLogger(SimplexOutgoingSession.class.getName());
+			getLogger(SimplexOutgoingSession.class.getName());
 
 	private static final ThrowingRunnable<IOException> CLOSE = () -> {
 	};

bramble-core/src/main/java/org/briarproject/bramble/sync/SyncRecordReaderImpl.java

@@ -12,7 +12,6 @@ import org.briarproject.bramble.api.sync.MessageId;
 import org.briarproject.bramble.api.sync.Offer;
 import org.briarproject.bramble.api.sync.Request;
 import org.briarproject.bramble.api.sync.SyncRecordReader;
-import org.briarproject.bramble.util.ByteUtils;
 
 import java.io.EOFException;
 import java.io.IOException;
@@ -28,6 +27,7 @@ import static org.briarproject.bramble.api.sync.RecordTypes.OFFER;
 import static org.briarproject.bramble.api.sync.RecordTypes.REQUEST;
 import static org.briarproject.bramble.api.sync.SyncConstants.MESSAGE_HEADER_LENGTH;
 import static org.briarproject.bramble.api.sync.SyncConstants.PROTOCOL_VERSION;
+import static org.briarproject.bramble.util.ByteUtils.readUint64;
 
 @NotThreadSafe
 @NotNullByDefault
@@ -127,7 +127,7 @@ class SyncRecordReaderImpl implements SyncRecordReader {
 		if (payload.length <= MESSAGE_HEADER_LENGTH)
 			throw new FormatException();
 		// Validate timestamp
-		long timestamp = ByteUtils.readUint64(payload, UniqueId.LENGTH);
+		long timestamp = readUint64(payload, UniqueId.LENGTH);
 		if (timestamp < 0) throw new FormatException();
 		nextRecord = null;
 		return messageFactory.createMessage(payload);

bramble-core/src/main/java/org/briarproject/bramble/sync/validation/ValidationManagerImpl.java

@@ -40,6 +40,7 @@ import javax.inject.Inject;
 
 import static java.util.logging.Level.INFO;
 import static java.util.logging.Level.WARNING;
+import static java.util.logging.Logger.getLogger;
 import static org.briarproject.bramble.api.sync.validation.MessageState.DELIVERED;
 import static org.briarproject.bramble.api.sync.validation.MessageState.INVALID;
 import static org.briarproject.bramble.api.sync.validation.MessageState.PENDING;
@@ -51,7 +52,7 @@ class ValidationManagerImpl implements ValidationManager, Service,
 		EventListener {
 
 	private static final Logger LOG =
-			Logger.getLogger(ValidationManagerImpl.class.getName());
+			getLogger(ValidationManagerImpl.class.getName());
 
 	private final DatabaseComponent db;
 	private final Executor dbExecutor, validationExecutor;

bramble-core/src/main/java/org/briarproject/bramble/transport/KeyManagerImpl.java

@@ -34,13 +34,13 @@ import javax.annotation.concurrent.ThreadSafe;
 import javax.inject.Inject;
 
 import static java.util.logging.Level.INFO;
+import static java.util.logging.Logger.getLogger;
 
 @ThreadSafe
 @NotNullByDefault
 class KeyManagerImpl implements KeyManager, Service, EventListener {
 
-	private static final Logger LOG =
+	private static final Logger LOG = getLogger(KeyManagerImpl.class.getName());
-			Logger.getLogger(KeyManagerImpl.class.getName());
 
 	private final DatabaseComponent db;
 	private final Executor dbExecutor;

bramble-core/src/main/java/org/briarproject/bramble/transport/TransportKeyManagerImpl.java

@@ -32,6 +32,7 @@ import javax.annotation.concurrent.ThreadSafe;
 
 import static java.util.concurrent.TimeUnit.MILLISECONDS;
 import static java.util.logging.Level.WARNING;
+import static java.util.logging.Logger.getLogger;
 import static org.briarproject.bramble.api.transport.TransportConstants.MAX_CLOCK_DIFFERENCE;
 import static org.briarproject.bramble.api.transport.TransportConstants.PROTOCOL_VERSION;
 import static org.briarproject.bramble.api.transport.TransportConstants.TAG_LENGTH;
@@ -43,7 +44,7 @@ import static org.briarproject.bramble.util.LogUtils.logException;
 class TransportKeyManagerImpl implements TransportKeyManager {
 
 	private static final Logger LOG =
-			Logger.getLogger(TransportKeyManagerImpl.class.getName());
+			getLogger(TransportKeyManagerImpl.class.getName());
 
 	private final DatabaseComponent db;
 	private final TransportCrypto transportCrypto;

bramble-core/src/test/java/org/briarproject/bramble/client/ClientHelperImplTest.java

@@ -23,7 +23,6 @@ import org.briarproject.bramble.api.sync.MessageFactory;
 import org.briarproject.bramble.api.sync.MessageId;
 import org.briarproject.bramble.test.BrambleTestCase;
 import org.briarproject.bramble.test.DbExpectations;
-import org.briarproject.bramble.util.StringUtils;
 import org.jmock.Expectations;
 import org.jmock.Mockery;
 import org.junit.Test;
@@ -74,7 +73,7 @@ public class ClientHelperImplTest extends BrambleTestCase {
 	private final long timestamp = message.getTimestamp();
 	private final Metadata metadata = new Metadata();
 	private final BdfList list = BdfList.of("Sign this!", getRandomBytes(42));
-	private final String label = StringUtils.getRandomString(5);
+	private final String label = getRandomString(5);
 	private final Author author = getAuthor();
 
 	private final ClientHelper clientHelper = new ClientHelperImpl(db,

bramble-core/src/test/java/org/briarproject/bramble/crypto/Blake2bDigestTest.java

@@ -1,12 +1,12 @@
 package org.briarproject.bramble.crypto;
 
 import org.briarproject.bramble.test.BrambleTestCase;
-import org.briarproject.bramble.util.StringUtils;
 import org.junit.Test;
 import org.spongycastle.crypto.digests.Blake2bDigest;
 
 import java.util.Random;
 
+import static org.briarproject.bramble.util.StringUtils.fromHexString;
 import static org.junit.Assert.assertArrayEquals;
 
 public class Blake2bDigestTest extends BrambleTestCase {
@@ -49,9 +49,9 @@ public class Blake2bDigestTest extends BrambleTestCase {
 	@Test
 	public void testDigestWithKeyedTestVectors() {
 		for (String[] keyedTestVector : KEYED_TEST_VECTORS) {
-			byte[] input = StringUtils.fromHexString(keyedTestVector[0]);
+			byte[] input = fromHexString(keyedTestVector[0]);
-			byte[] key = StringUtils.fromHexString(keyedTestVector[1]);
+			byte[] key = fromHexString(keyedTestVector[1]);
-			byte[] expected = StringUtils.fromHexString(keyedTestVector[2]);
+			byte[] expected = fromHexString(keyedTestVector[2]);
 
 			Blake2bDigest digest = new Blake2bDigest(key);
 			digest.update(input, 0, input.length);
@@ -67,10 +67,10 @@ public class Blake2bDigestTest extends BrambleTestCase {
 		Random random = new Random();
 		for (int i = 0; i < 100; i++) {
 			for (String[] keyedTestVector : KEYED_TEST_VECTORS) {
-				byte[] input = StringUtils.fromHexString(keyedTestVector[0]);
+				byte[] input = fromHexString(keyedTestVector[0]);
 				if (input.length == 0) continue;
-				byte[] key = StringUtils.fromHexString(keyedTestVector[1]);
+				byte[] key = fromHexString(keyedTestVector[1]);
-				byte[] expected = StringUtils.fromHexString(keyedTestVector[2]);
+				byte[] expected = fromHexString(keyedTestVector[2]);
 
 				Blake2bDigest digest = new Blake2bDigest(key);
 
@@ -168,6 +168,6 @@ public class Blake2bDigestTest extends BrambleTestCase {
 
 		byte[] hash = new byte[32];
 		testDigest.doFinal(hash, 0);
-		assertArrayEquals(StringUtils.fromHexString(SELF_TEST_RESULT), hash);
+		assertArrayEquals(fromHexString(SELF_TEST_RESULT), hash);
 	}
 }

bramble-core/src/test/java/org/briarproject/bramble/crypto/HashTest.java

@@ -3,12 +3,12 @@ package org.briarproject.bramble.crypto;
 import org.briarproject.bramble.api.crypto.CryptoComponent;
 import org.briarproject.bramble.test.BrambleTestCase;
 import org.briarproject.bramble.test.TestSecureRandomProvider;
-import org.briarproject.bramble.test.TestUtils;
-import org.briarproject.bramble.util.StringUtils;
 import org.junit.Test;
 
 import java.util.Arrays;
 
+import static org.briarproject.bramble.test.TestUtils.getRandomBytes;
+import static org.briarproject.bramble.util.StringUtils.getRandomString;
 import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertFalse;
 
@@ -16,9 +16,9 @@ public class HashTest extends BrambleTestCase {
 
 	private final CryptoComponent crypto;
 
-	private final String label = StringUtils.getRandomString(42);
+	private final String label = getRandomString(42);
-	private final byte[] inputBytes = TestUtils.getRandomBytes(123);
+	private final byte[] inputBytes = getRandomBytes(123);
-	private final byte[] inputBytes1 = TestUtils.getRandomBytes(234);
+	private final byte[] inputBytes1 = getRandomBytes(234);
 	private final byte[] inputBytes2 = new byte[0];
 
 	public HashTest() {
@@ -41,7 +41,7 @@ public class HashTest extends BrambleTestCase {
 
 	@Test
 	public void testDifferentLabelsProduceDifferentHashes() {
-		String label2 = StringUtils.getRandomString(42);
+		String label2 = getRandomString(42);
 		byte[] hash1 = crypto.hash(label, inputBytes, inputBytes1, inputBytes2);
 		byte[] hash2 =
 				crypto.hash(label2, inputBytes, inputBytes1, inputBytes2);

bramble-core/src/test/java/org/briarproject/bramble/crypto/PasswordBasedEncryptionTest.java

@@ -3,11 +3,11 @@ package org.briarproject.bramble.crypto;
 import org.briarproject.bramble.system.SystemClock;
 import org.briarproject.bramble.test.BrambleTestCase;
 import org.briarproject.bramble.test.TestSecureRandomProvider;
-import org.briarproject.bramble.test.TestUtils;
 import org.junit.Test;
 
 import java.util.Random;
 
+import static org.briarproject.bramble.test.TestUtils.getRandomBytes;
 import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertNull;
 
@@ -19,7 +19,7 @@ public class PasswordBasedEncryptionTest extends BrambleTestCase {
 
 	@Test
 	public void testEncryptionAndDecryption() {
-		byte[] input = TestUtils.getRandomBytes(1234);
+		byte[] input = getRandomBytes(1234);
 		String password = "password";
 		byte[] ciphertext = crypto.encryptWithPassword(input, password);
 		byte[] output = crypto.decryptWithPassword(ciphertext, password);
@@ -28,7 +28,7 @@ public class PasswordBasedEncryptionTest extends BrambleTestCase {
 
 	@Test
 	public void testInvalidCiphertextReturnsNull() {
-		byte[] input = TestUtils.getRandomBytes(1234);
+		byte[] input = getRandomBytes(1234);
 		String password = "password";
 		byte[] ciphertext = crypto.encryptWithPassword(input, password);
 		// Modify the ciphertext

bramble-core/src/test/java/org/briarproject/bramble/crypto/ScryptKdfTest.java

@@ -4,6 +4,7 @@ import org.briarproject.bramble.api.Bytes;
 import org.briarproject.bramble.api.crypto.SecretKey;
 import org.briarproject.bramble.api.system.Clock;
 import org.briarproject.bramble.system.SystemClock;
+import org.briarproject.bramble.test.ArrayClock;
 import org.briarproject.bramble.test.BrambleTestCase;
 import org.junit.Test;
 
@@ -11,8 +12,6 @@ import java.util.HashSet;
 import java.util.Set;
 
 import static junit.framework.TestCase.assertTrue;
-
-import org.briarproject.bramble.test.ArrayClock;
 import static org.briarproject.bramble.test.TestUtils.getRandomBytes;
 import static org.briarproject.bramble.util.StringUtils.getRandomString;
 import static org.junit.Assert.assertEquals;

bramble-core/src/test/java/org/briarproject/bramble/crypto/SignatureTest.java

@@ -4,13 +4,13 @@ import org.briarproject.bramble.api.crypto.CryptoComponent;
 import org.briarproject.bramble.api.crypto.KeyPair;
 import org.briarproject.bramble.test.BrambleTestCase;
 import org.briarproject.bramble.test.TestSecureRandomProvider;
-import org.briarproject.bramble.test.TestUtils;
-import org.briarproject.bramble.util.StringUtils;
 import org.junit.Test;
 
 import java.security.GeneralSecurityException;
 import java.util.Arrays;
 
+import static org.briarproject.bramble.test.TestUtils.getRandomBytes;
+import static org.briarproject.bramble.util.StringUtils.getRandomString;
 import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
@@ -20,8 +20,8 @@ public abstract class SignatureTest extends BrambleTestCase {
 	protected final CryptoComponent crypto;
 
 	private final byte[] publicKey, privateKey;
-	private final String label = StringUtils.getRandomString(42);
+	private final String label = getRandomString(42);
-	private final byte[] inputBytes = TestUtils.getRandomBytes(123);
+	private final byte[] inputBytes = getRandomBytes(123);
 
 	protected abstract KeyPair generateKeyPair();
 
@@ -62,7 +62,7 @@ public abstract class SignatureTest extends BrambleTestCase {
 	public void testDifferentInputsProduceDifferentSignatures()
 			throws Exception {
 		// Generate a second input
-		byte[] inputBytes2 = TestUtils.getRandomBytes(123);
+		byte[] inputBytes2 = getRandomBytes(123);
 		// Calculate the signature with different inputs
 		// the results should be different
 		byte[] sig1 = sign(label, inputBytes, privateKey);
@@ -74,7 +74,7 @@ public abstract class SignatureTest extends BrambleTestCase {
 	public void testDifferentLabelsProduceDifferentSignatures()
 			throws Exception {
 		// Generate a second label
-		String label2 = StringUtils.getRandomString(42);
+		String label2 = getRandomString(42);
 		// Calculate the signature with different inputs
 		// the results should be different
 		byte[] sig1 = sign(label, inputBytes, privateKey);
@@ -101,7 +101,7 @@ public abstract class SignatureTest extends BrambleTestCase {
 	@Test
 	public void testDifferentInputFailsVerification() throws Exception {
 		// Generate a second input
-		byte[] inputBytes2 = TestUtils.getRandomBytes(123);
+		byte[] inputBytes2 = getRandomBytes(123);
 		// calculate the signature with different input, should fail to verify
 		byte[] sig = sign(label, inputBytes, privateKey);
 		assertFalse(verify(sig, label, inputBytes2, publicKey));
@@ -110,7 +110,7 @@ public abstract class SignatureTest extends BrambleTestCase {
 	@Test
 	public void testDifferentLabelFailsVerification() throws Exception {
 		// Generate a second label
-		String label2 = StringUtils.getRandomString(42);
+		String label2 = getRandomString(42);
 		// calculate the signature with different label, should fail to verify
 		byte[] sig = sign(label, inputBytes, privateKey);
 		assertFalse(verify(sig, label2, inputBytes, publicKey));

bramble-core/src/test/java/org/briarproject/bramble/crypto/StreamDecrypterImplTest.java

@@ -2,8 +2,6 @@ package org.briarproject.bramble.crypto;
 
 import org.briarproject.bramble.api.crypto.SecretKey;
 import org.briarproject.bramble.test.BrambleTestCase;
-import org.briarproject.bramble.test.TestUtils;
-import org.briarproject.bramble.util.ByteUtils;
 import org.junit.Test;
 
 import java.io.ByteArrayInputStream;
@@ -16,7 +14,11 @@ import static org.briarproject.bramble.api.transport.TransportConstants.MAC_LENG
 import static org.briarproject.bramble.api.transport.TransportConstants.MAX_PAYLOAD_LENGTH;
 import static org.briarproject.bramble.api.transport.TransportConstants.PROTOCOL_VERSION;
 import static org.briarproject.bramble.api.transport.TransportConstants.STREAM_HEADER_NONCE_LENGTH;
+import static org.briarproject.bramble.test.TestUtils.getRandomBytes;
+import static org.briarproject.bramble.test.TestUtils.getSecretKey;
 import static org.briarproject.bramble.util.ByteUtils.INT_16_BYTES;
+import static org.briarproject.bramble.util.ByteUtils.writeUint16;
+import static org.briarproject.bramble.util.ByteUtils.writeUint64;
 import static org.junit.Assert.assertArrayEquals;
 
 public class StreamDecrypterImplTest extends BrambleTestCase {
@@ -30,15 +32,14 @@ public class StreamDecrypterImplTest extends BrambleTestCase {
 
 	public StreamDecrypterImplTest() {
 		cipher = new TestAuthenticatedCipher(); // Null cipher
-		streamHeaderKey = TestUtils.getSecretKey();
+		streamHeaderKey = getSecretKey();
-		frameKey = TestUtils.getSecretKey();
+		frameKey = getSecretKey();
-		streamHeaderNonce =
+		streamHeaderNonce = getRandomBytes(STREAM_HEADER_NONCE_LENGTH);
-				TestUtils.getRandomBytes(STREAM_HEADER_NONCE_LENGTH);
 		protocolVersionBytes = new byte[2];
-		ByteUtils.writeUint16(PROTOCOL_VERSION, protocolVersionBytes, 0);
+		writeUint16(PROTOCOL_VERSION, protocolVersionBytes, 0);
 		streamNumberBytes = new byte[8];
-		ByteUtils.writeUint64(streamNumber, streamNumberBytes, 0);
+		writeUint64(streamNumber, streamNumberBytes, 0);
-		payload = TestUtils.getRandomBytes(payloadLength);
+		payload = getRandomBytes(payloadLength);
 	}
 
 	@Test
@@ -51,7 +52,7 @@ public class StreamDecrypterImplTest extends BrambleTestCase {
 		int payloadLength1 = 345, paddingLength1 = 456;
 		FrameEncoder.encodeHeader(frameHeader1, true, payloadLength1,
 				paddingLength1);
-		byte[] payload1 = TestUtils.getRandomBytes(payloadLength1);
+		byte[] payload1 = getRandomBytes(payloadLength1);
 
 		ByteArrayOutputStream out = new ByteArrayOutputStream();
 		out.write(streamHeaderNonce);
@@ -88,8 +89,7 @@ public class StreamDecrypterImplTest extends BrambleTestCase {
 	@Test(expected = IOException.class)
 	public void testWrongProtocolVersionThrowsException() throws Exception {
 		byte[] wrongProtocolVersionBytes = new byte[2];
-		ByteUtils.writeUint16(PROTOCOL_VERSION + 1, wrongProtocolVersionBytes,
+		writeUint16(PROTOCOL_VERSION + 1, wrongProtocolVersionBytes, 0);
-				0);
 
 		byte[] frameHeader = new byte[FRAME_HEADER_LENGTH];
 		FrameEncoder.encodeHeader(frameHeader, false, payloadLength,
@@ -99,7 +99,7 @@ public class StreamDecrypterImplTest extends BrambleTestCase {
 		int payloadLength1 = 345, paddingLength1 = 456;
 		FrameEncoder.encodeHeader(frameHeader1, true, payloadLength1,
 				paddingLength1);
-		byte[] payload1 = TestUtils.getRandomBytes(payloadLength1);
+		byte[] payload1 = getRandomBytes(payloadLength1);
 
 		ByteArrayOutputStream out = new ByteArrayOutputStream();
 		out.write(streamHeaderNonce);
@@ -128,7 +128,7 @@ public class StreamDecrypterImplTest extends BrambleTestCase {
 	@Test(expected = IOException.class)
 	public void testWrongStreamNumberThrowsException() throws Exception {
 		byte[] wrongStreamNumberBytes = new byte[8];
-		ByteUtils.writeUint64(streamNumber + 1, wrongStreamNumberBytes, 0);
+		writeUint64(streamNumber + 1, wrongStreamNumberBytes, 0);
 
 		byte[] frameHeader = new byte[FRAME_HEADER_LENGTH];
 		FrameEncoder.encodeHeader(frameHeader, false, payloadLength,
@@ -138,7 +138,7 @@ public class StreamDecrypterImplTest extends BrambleTestCase {
 		int payloadLength1 = 345, paddingLength1 = 456;
 		FrameEncoder.encodeHeader(frameHeader1, true, payloadLength1,
 				paddingLength1);
-		byte[] payload1 = TestUtils.getRandomBytes(payloadLength1);
+		byte[] payload1 = getRandomBytes(payloadLength1);
 
 		ByteArrayOutputStream out = new ByteArrayOutputStream();
 		out.write(streamHeaderNonce);
@@ -196,9 +196,9 @@ public class StreamDecrypterImplTest extends BrambleTestCase {
 		byte[] frameHeader = new byte[FRAME_HEADER_LENGTH];
 		// The payload length plus padding length is invalid
 		int payloadLength = MAX_PAYLOAD_LENGTH - 1, paddingLength = 2;
-		ByteUtils.writeUint16(payloadLength, frameHeader, 0);
+		writeUint16(payloadLength, frameHeader, 0);
-		ByteUtils.writeUint16(paddingLength, frameHeader, INT_16_BYTES);
+		writeUint16(paddingLength, frameHeader, INT_16_BYTES);
-		byte[] payload = TestUtils.getRandomBytes(payloadLength);
+		byte[] payload = getRandomBytes(payloadLength);
 
 		ByteArrayOutputStream out = new ByteArrayOutputStream();
 		out.write(streamHeaderNonce);

bramble-core/src/test/java/org/briarproject/bramble/crypto/StreamEncrypterImplTest.java

@@ -2,8 +2,6 @@ package org.briarproject.bramble.crypto;
 
 import org.briarproject.bramble.api.crypto.SecretKey;
 import org.briarproject.bramble.test.BrambleTestCase;
-import org.briarproject.bramble.test.TestUtils;
-import org.briarproject.bramble.util.ByteUtils;
 import org.junit.Test;
 
 import java.io.ByteArrayOutputStream;
@@ -16,6 +14,10 @@ import static org.briarproject.bramble.api.transport.TransportConstants.PROTOCOL
 import static org.briarproject.bramble.api.transport.TransportConstants.STREAM_HEADER_LENGTH;
 import static org.briarproject.bramble.api.transport.TransportConstants.STREAM_HEADER_NONCE_LENGTH;
 import static org.briarproject.bramble.api.transport.TransportConstants.TAG_LENGTH;
+import static org.briarproject.bramble.test.TestUtils.getRandomBytes;
+import static org.briarproject.bramble.test.TestUtils.getSecretKey;
+import static org.briarproject.bramble.util.ByteUtils.writeUint16;
+import static org.briarproject.bramble.util.ByteUtils.writeUint64;
 import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertEquals;
 
@@ -30,16 +32,15 @@ public class StreamEncrypterImplTest extends BrambleTestCase {
 
 	public StreamEncrypterImplTest() {
 		cipher = new TestAuthenticatedCipher(); // Null cipher
-		streamHeaderKey = TestUtils.getSecretKey();
+		streamHeaderKey = getSecretKey();
-		frameKey = TestUtils.getSecretKey();
+		frameKey = getSecretKey();
-		tag = TestUtils.getRandomBytes(TAG_LENGTH);
+		tag = getRandomBytes(TAG_LENGTH);
-		streamHeaderNonce =
+		streamHeaderNonce = getRandomBytes(STREAM_HEADER_NONCE_LENGTH);
-				TestUtils.getRandomBytes(STREAM_HEADER_NONCE_LENGTH);
 		protocolVersionBytes = new byte[2];
-		ByteUtils.writeUint16(PROTOCOL_VERSION, protocolVersionBytes, 0);
+		writeUint16(PROTOCOL_VERSION, protocolVersionBytes, 0);
 		streamNumberBytes = new byte[8];
-		ByteUtils.writeUint64(streamNumber, streamNumberBytes, 0);
+		writeUint64(streamNumber, streamNumberBytes, 0);
-		payload = TestUtils.getRandomBytes(payloadLength);
+		payload = getRandomBytes(payloadLength);
 	}
 
 	@Test(expected = IllegalArgumentException.class)
@@ -318,7 +319,7 @@ public class StreamEncrypterImplTest extends BrambleTestCase {
 				streamNumber, tag, streamHeaderNonce, streamHeaderKey,
 				frameKey);
 		int payloadLength1 = 345, paddingLength1 = 456;
-		byte[] payload1 = TestUtils.getRandomBytes(payloadLength1);
+		byte[] payload1 = getRandomBytes(payloadLength1);
 
 		s.writeFrame(payload, payloadLength, paddingLength, false);
 		s.writeFrame(payload1, payloadLength1, paddingLength1, true);

bramble-core/src/test/java/org/briarproject/bramble/crypto/XSalsa20Poly1305AuthenticatedCipherTest.java

@@ -2,12 +2,12 @@ package org.briarproject.bramble.crypto;
 
 import org.briarproject.bramble.api.crypto.SecretKey;
 import org.briarproject.bramble.test.BrambleTestCase;
-import org.briarproject.bramble.util.StringUtils;
 import org.junit.Test;
 
 import java.security.GeneralSecurityException;
 import java.util.Random;
 
+import static org.briarproject.bramble.util.StringUtils.fromHexString;
 import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertEquals;
 
@@ -15,11 +15,11 @@ public class XSalsa20Poly1305AuthenticatedCipherTest extends BrambleTestCase {
 
 	// Test vectors from the NaCl paper
 	// http://cr.yp.to/highspeed/naclcrypto-20090310.pdf
-	private static final byte[] TEST_KEY = StringUtils.fromHexString(
+	private static final byte[] TEST_KEY = fromHexString(
 			"1b27556473e985d462cd51197a9a46c76009549eac6474f206c4ee0844f68389");
-	private static final byte[] TEST_IV = StringUtils.fromHexString(
+	private static final byte[] TEST_IV = fromHexString(
 			"69696ee955b62b73cd62bda875fc73d68219e0036b7a0b37");
-	private static final byte[] TEST_PLAINTEXT = StringUtils.fromHexString(
+	private static final byte[] TEST_PLAINTEXT = fromHexString(
 					"be075fc53c81f2d5cf141316" +
 					"ebeb0c7b5228c52a4c62cbd4" +
 					"4b66849b64244ffce5ecbaaf" +
@@ -31,7 +31,7 @@ public class XSalsa20Poly1305AuthenticatedCipherTest extends BrambleTestCase {
 					"048977eb48f59ffd4924ca1c" +
 					"60902e52f0a089bc76897040" +
 					"e082f937763848645e0705");
-	private static final byte[] TEST_CIPHERTEXT = StringUtils.fromHexString(
+	private static final byte[] TEST_CIPHERTEXT = fromHexString(
 					"f3ffc7703f9400e52a7dfb4b" +
 					"3d3305d98e993b9f48681273" +
 					"c29650ba32fc76ce48332ea7" +

bramble-core/src/test/java/org/briarproject/bramble/data/BdfWriterImplTest.java

@@ -1,7 +1,6 @@
 package org.briarproject.bramble.data;
 
 import org.briarproject.bramble.test.BrambleTestCase;
-import org.briarproject.bramble.util.StringUtils;
 import org.junit.Before;
 import org.junit.Test;
 
@@ -13,6 +12,9 @@ import java.util.List;
 import java.util.Map;
 
 import static org.briarproject.bramble.api.data.BdfDictionary.NULL_VALUE;
+import static org.briarproject.bramble.util.StringUtils.fromHexString;
+import static org.briarproject.bramble.util.StringUtils.getRandomString;
+import static org.briarproject.bramble.util.StringUtils.toHexString;
 import static org.junit.Assert.assertArrayEquals;
 
 public class BdfWriterImplTest extends BrambleTestCase {
@@ -80,8 +82,8 @@ public class BdfWriterImplTest extends BrambleTestCase {
 
 	@Test
 	public void testWriteString8() throws IOException {
-		String longest = StringUtils.getRandomString(Byte.MAX_VALUE);
+		String longest = getRandomString(Byte.MAX_VALUE);
-		String longHex = StringUtils.toHexString(longest.getBytes("UTF-8"));
+		String longHex = toHexString(longest.getBytes("UTF-8"));
 		w.writeString("foo bar baz bam ");
 		w.writeString(longest);
 		// STRING_8 tag, length 16, UTF-8 bytes, STRING_8 tag, length 127,
@@ -92,10 +94,10 @@ public class BdfWriterImplTest extends BrambleTestCase {
 
 	@Test
 	public void testWriteString16() throws IOException {
-		String shortest = StringUtils.getRandomString(Byte.MAX_VALUE + 1);
+		String shortest = getRandomString(Byte.MAX_VALUE + 1);
-		String shortHex = StringUtils.toHexString(shortest.getBytes("UTF-8"));
+		String shortHex = toHexString(shortest.getBytes("UTF-8"));
-		String longest = StringUtils.getRandomString(Short.MAX_VALUE);
+		String longest = getRandomString(Short.MAX_VALUE);
-		String longHex = StringUtils.toHexString(longest.getBytes("UTF-8"));
+		String longHex = toHexString(longest.getBytes("UTF-8"));
 		w.writeString(shortest);
 		w.writeString(longest);
 		// STRING_16 tag, length 128, UTF-8 bytes, STRING_16 tag,
@@ -105,8 +107,8 @@ public class BdfWriterImplTest extends BrambleTestCase {
 
 	@Test
 	public void testWriteString32() throws IOException {
-		String shortest = StringUtils.getRandomString(Short.MAX_VALUE + 1);
+		String shortest = getRandomString(Short.MAX_VALUE + 1);
-		String shortHex = StringUtils.toHexString(shortest.getBytes("UTF-8"));
+		String shortHex = toHexString(shortest.getBytes("UTF-8"));
 		w.writeString(shortest);
 		// STRING_32 tag, length 2^15, UTF-8 bytes
 		checkContents("44" + "00008000" + shortHex);
@@ -115,7 +117,7 @@ public class BdfWriterImplTest extends BrambleTestCase {
 	@Test
 	public void testWriteUtf8String() throws IOException {
 		String unicode = "\uFDD0\uFDD1\uFDD2\uFDD3";
-		String hex = StringUtils.toHexString(unicode.getBytes("UTF-8"));
+		String hex = toHexString(unicode.getBytes("UTF-8"));
 		w.writeString(unicode);
 		// STRING_8 tag, length 12, UTF-8 bytes
 		checkContents("41" + "0C" + hex);
@@ -124,7 +126,7 @@ public class BdfWriterImplTest extends BrambleTestCase {
 	@Test
 	public void testWriteRaw8() throws IOException {
 		byte[] longest = new byte[Byte.MAX_VALUE];
-		String longHex = StringUtils.toHexString(longest);
+		String longHex = toHexString(longest);
 		w.writeRaw(new byte[] {1, 2, 3});
 		w.writeRaw(longest);
 		// RAW_8 tag, length 3, bytes, RAW_8 tag, length 127, bytes
@@ -134,9 +136,9 @@ public class BdfWriterImplTest extends BrambleTestCase {
 	@Test
 	public void testWriteRaw16() throws IOException {
 		byte[] shortest = new byte[Byte.MAX_VALUE + 1];
-		String shortHex = StringUtils.toHexString(shortest);
+		String shortHex = toHexString(shortest);
 		byte[] longest = new byte[Short.MAX_VALUE];
-		String longHex = StringUtils.toHexString(longest);
+		String longHex = toHexString(longest);
 		w.writeRaw(shortest);
 		w.writeRaw(longest);
 		// RAW_16 tag, length 128, bytes, RAW_16 tag, length 2^15 - 1, bytes
@@ -146,7 +148,7 @@ public class BdfWriterImplTest extends BrambleTestCase {
 	@Test
 	public void testWriteRaw32() throws IOException {
 		byte[] shortest = new byte[Short.MAX_VALUE + 1];
-		String shortHex = StringUtils.toHexString(shortest);
+		String shortHex = toHexString(shortest);
 		w.writeRaw(shortest);
 		// RAW_32 tag, length 2^15, bytes
 		checkContents("54" + "00008000" + shortHex);
@@ -233,8 +235,8 @@ public class BdfWriterImplTest extends BrambleTestCase {
 	private void checkContents(String hex) throws IOException {
 		out.flush();
 		out.close();
-		byte[] expected = StringUtils.fromHexString(hex);
+		byte[] expected = fromHexString(hex);
-		assertArrayEquals(StringUtils.toHexString(out.toByteArray()),
+		assertArrayEquals(toHexString(out.toByteArray()),
 				expected, out.toByteArray());
 	}
 }

bramble-core/src/test/java/org/briarproject/bramble/db/BasicDatabaseTest.java

@@ -1,8 +1,6 @@
 package org.briarproject.bramble.db;
 
 import org.briarproject.bramble.test.BrambleTestCase;
-import org.briarproject.bramble.test.TestUtils;
-import org.briarproject.bramble.util.StringUtils;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
@@ -19,6 +17,10 @@ import java.util.ArrayList;
 import java.util.List;
 
 import static java.sql.Types.BINARY;
+import static org.briarproject.bramble.test.TestUtils.deleteTestDirectory;
+import static org.briarproject.bramble.test.TestUtils.getRandomId;
+import static org.briarproject.bramble.test.TestUtils.getTestDirectory;
+import static org.briarproject.bramble.util.StringUtils.getRandomString;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
@@ -30,7 +32,7 @@ public abstract class BasicDatabaseTest extends BrambleTestCase {
 
 	private static final int BATCH_SIZE = 100;
 
-	private final File testDir = TestUtils.getTestDirectory();
+	private final File testDir = getTestDirectory();
 	private final File db = new File(testDir, "db");
 
 	protected abstract String getBinaryType();
@@ -56,9 +58,9 @@ public abstract class BasicDatabaseTest extends BrambleTestCase {
 			// Create the table
 			createTable(connection);
 			// Generate an ID and two names
-			byte[] id = TestUtils.getRandomId();
+			byte[] id = getRandomId();
-			String oldName = StringUtils.getRandomString(50);
+			String oldName = getRandomString(50);
-			String newName = StringUtils.getRandomString(50);
+			String newName = getRandomString(50);
 			// Insert the ID and old name into the table
 			insertRow(connection, id, oldName);
 			// Check that the old name can be retrieved using the ID
@@ -92,9 +94,9 @@ public abstract class BasicDatabaseTest extends BrambleTestCase {
 			String[] oldNames = new String[BATCH_SIZE];
 			String[] newNames = new String[BATCH_SIZE];
 			for (int i = 0; i < BATCH_SIZE; i++) {
-				ids[i] = TestUtils.getRandomId();
+				ids[i] = getRandomId();
-				oldNames[i] = StringUtils.getRandomString(50);
+				oldNames[i] = getRandomString(50);
-				newNames[i] = StringUtils.getRandomString(50);
+				newNames[i] = getRandomString(50);
 			}
 			// Insert the IDs and old names into the table as a batch
 			insertBatch(connection, ids, oldNames);
@@ -374,7 +376,7 @@ public abstract class BasicDatabaseTest extends BrambleTestCase {
 	}
 
 	@After
-	public void tearDown() throws Exception {
+	public void tearDown() {
-		TestUtils.deleteTestDirectory(testDir);
+		deleteTestDirectory(testDir);
 	}
 }

bramble-core/src/test/java/org/briarproject/bramble/db/BasicH2Test.java

@@ -1,8 +1,6 @@
 package org.briarproject.bramble.db;
 
 import org.briarproject.bramble.api.crypto.SecretKey;
-import org.briarproject.bramble.test.TestUtils;
-import org.briarproject.bramble.util.StringUtils;
 
 import java.io.File;
 import java.sql.Connection;
@@ -10,9 +8,12 @@ import java.sql.DriverManager;
 import java.sql.SQLException;
 import java.util.Properties;
 
+import static org.briarproject.bramble.test.TestUtils.getSecretKey;
+import static org.briarproject.bramble.util.StringUtils.toHexString;
+
 public class BasicH2Test extends BasicDatabaseTest {
 
-	private final SecretKey key = TestUtils.getSecretKey();
+	private final SecretKey key = getSecretKey();
 
 	@Override
 	protected String getBinaryType() {
@@ -32,7 +33,7 @@ public class BasicH2Test extends BasicDatabaseTest {
 		props.setProperty("user", "user");
 		if (encrypt) {
 			url += ";CIPHER=AES";
-			String hex = StringUtils.toHexString(key.getBytes());
+			String hex = toHexString(key.getBytes());
 			props.setProperty("password", hex + " password");
 		}
 		return DriverManager.getConnection(url, props);

bramble-core/src/test/java/org/briarproject/bramble/db/BasicHyperSqlTest.java

@@ -1,8 +1,6 @@
 package org.briarproject.bramble.db;
 
 import org.briarproject.bramble.api.crypto.SecretKey;
-import org.briarproject.bramble.test.TestUtils;
-import org.briarproject.bramble.util.StringUtils;
 
 import java.io.File;
 import java.sql.Connection;
@@ -10,9 +8,12 @@ import java.sql.DriverManager;
 import java.sql.SQLException;
 import java.sql.Statement;
 
+import static org.briarproject.bramble.test.TestUtils.getSecretKey;
+import static org.briarproject.bramble.util.StringUtils.toHexString;
+
 public class BasicHyperSqlTest extends BasicDatabaseTest {
 
-	private final SecretKey key = TestUtils.getSecretKey();
+	private final SecretKey key = getSecretKey();
 
 	@Override
 	protected String getBinaryType() {
@@ -30,7 +31,7 @@ public class BasicHyperSqlTest extends BasicDatabaseTest {
 		String url = "jdbc:hsqldb:file:" + db.getAbsolutePath() +
 				";sql.enforce_size=false;allow_empty_batch=true";
 		if (encrypt) {
-			String hex = StringUtils.toHexString(key.getBytes());
+			String hex = toHexString(key.getBytes());
 			url += ";encrypt_lobs=true;crypt_type=AES;crypt_key=" + hex;
 		}
 		return DriverManager.getConnection(url);

bramble-core/src/test/java/org/briarproject/bramble/db/DatabaseMigrationTest.java

@@ -13,7 +13,6 @@ import org.briarproject.bramble.system.SystemClock;
 import org.briarproject.bramble.test.BrambleMockTestCase;
 import org.briarproject.bramble.test.TestDatabaseConfig;
 import org.briarproject.bramble.test.TestMessageFactory;
-import org.briarproject.bramble.test.TestUtils;
 import org.jmock.Expectations;
 import org.junit.After;
 import org.junit.Before;
@@ -29,7 +28,9 @@ import static java.util.Collections.singletonList;
 import static org.briarproject.bramble.db.DatabaseConstants.DB_SETTINGS_NAMESPACE;
 import static org.briarproject.bramble.db.DatabaseConstants.SCHEMA_VERSION_KEY;
 import static org.briarproject.bramble.db.JdbcDatabase.CODE_SCHEMA_VERSION;
+import static org.briarproject.bramble.test.TestUtils.deleteTestDirectory;
 import static org.briarproject.bramble.test.TestUtils.getSecretKey;
+import static org.briarproject.bramble.test.TestUtils.getTestDirectory;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
@@ -37,7 +38,7 @@ import static org.junit.Assert.assertTrue;
 @NotNullByDefault
 public abstract class DatabaseMigrationTest extends BrambleMockTestCase {
 
-	private final File testDir = TestUtils.getTestDirectory();
+	private final File testDir = getTestDirectory();
 	@SuppressWarnings("unchecked")
 	private final Migration<Connection> migration =
 			context.mock(Migration.class, "migration");
@@ -61,7 +62,7 @@ public abstract class DatabaseMigrationTest extends BrambleMockTestCase {
 
 	@After
 	public void tearDown() {
-		TestUtils.deleteTestDirectory(testDir);
+		deleteTestDirectory(testDir);
 	}
 
 	@Test

bramble-core/src/test/java/org/briarproject/bramble/db/DatabasePerformanceTest.java

@@ -29,9 +29,9 @@ import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Random;
-import java.util.logging.Logger;
 
 import static java.util.logging.Level.OFF;
+import static java.util.logging.Logger.getLogger;
 import static org.briarproject.bramble.api.sync.SyncConstants.MAX_MESSAGE_IDS;
 import static org.briarproject.bramble.api.sync.validation.MessageState.DELIVERED;
 import static org.briarproject.bramble.test.TestUtils.deleteTestDirectory;
@@ -119,7 +119,7 @@ public abstract class DatabasePerformanceTest extends BrambleTestCase {
 
 	DatabasePerformanceTest() {
 		// Disable logging
-		Logger.getLogger("").setLevel(OFF);
+		getLogger("").setLevel(OFF);
 	}
 
 	@Before

bramble-core/src/test/java/org/briarproject/bramble/db/DatabaseTraceTest.java

@@ -8,7 +8,6 @@ import org.briarproject.bramble.api.system.Clock;
 import org.briarproject.bramble.system.SystemClock;
 import org.briarproject.bramble.test.TestDatabaseConfig;
 import org.briarproject.bramble.test.TestMessageFactory;
-import org.briarproject.bramble.util.IoUtils;
 
 import java.io.File;
 import java.io.FileInputStream;
@@ -20,6 +19,7 @@ import javax.annotation.Nullable;
 
 import static org.briarproject.bramble.test.TestUtils.deleteTestDirectory;
 import static org.briarproject.bramble.test.TestUtils.getSecretKey;
+import static org.briarproject.bramble.util.IoUtils.copyAndClose;
 
 public abstract class DatabaseTraceTest extends DatabasePerformanceTest {
 
@@ -58,7 +58,6 @@ public abstract class DatabaseTraceTest extends DatabasePerformanceTest {
 		if (!src.exists()) return;
 		String filename = getTestName() + "." + name + ".trace.txt";
 		File dest = new File(testDir.getParentFile(), filename);
-		IoUtils.copyAndClose(new FileInputStream(src),
+		copyAndClose(new FileInputStream(src), new FileOutputStream(dest));
-				new FileOutputStream(dest));
 	}
 }

bramble-core/src/test/java/org/briarproject/bramble/db/H2TransactionIsolationTest.java

@@ -1,7 +1,6 @@
 package org.briarproject.bramble.db;
 
 import org.briarproject.bramble.test.BrambleTestCase;
-import org.briarproject.bramble.test.TestUtils;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
@@ -14,6 +13,8 @@ import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.sql.Statement;
 
+import static org.briarproject.bramble.test.TestUtils.deleteTestDirectory;
+import static org.briarproject.bramble.test.TestUtils.getTestDirectory;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
@@ -32,7 +33,7 @@ public class H2TransactionIsolationTest extends BrambleTestCase {
 	private static final String SET_COUNTER =
 			"UPDATE foo SET counter = ? WHERE key = 1";
 
-	private final File testDir = TestUtils.getTestDirectory();
+	private final File testDir = getTestDirectory();
 	private final File db = new File(testDir, "db");
 	private final String withMvcc = "jdbc:h2:split:" + db.getAbsolutePath()
 			+ ";MV_STORE=TRUE;MVCC=TRUE";
@@ -47,7 +48,7 @@ public class H2TransactionIsolationTest extends BrambleTestCase {
 
 	@After
 	public void tearDown() throws Exception {
-		TestUtils.deleteTestDirectory(testDir);
+		deleteTestDirectory(testDir);
 	}
 
 	@Test

bramble-core/src/test/java/org/briarproject/bramble/record/RecordReaderImplTest.java

@@ -4,7 +4,6 @@ import org.briarproject.bramble.api.FormatException;
 import org.briarproject.bramble.api.record.Record;
 import org.briarproject.bramble.api.record.RecordReader;
 import org.briarproject.bramble.test.BrambleTestCase;
-import org.briarproject.bramble.util.ByteUtils;
 import org.junit.Test;
 
 import java.io.ByteArrayInputStream;
@@ -12,6 +11,7 @@ import java.io.EOFException;
 
 import static org.briarproject.bramble.api.record.Record.MAX_RECORD_PAYLOAD_BYTES;
 import static org.briarproject.bramble.api.record.Record.RECORD_HEADER_BYTES;
+import static org.briarproject.bramble.util.ByteUtils.writeUint16;
 import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertEquals;
 
@@ -36,7 +36,7 @@ public class RecordReaderImplTest extends BrambleTestCase {
 		// Version 1, type 2, payload length MAX_RECORD_PAYLOAD_BYTES
 		record[0] = 1;
 		record[1] = 2;
-		ByteUtils.writeUint16(MAX_RECORD_PAYLOAD_BYTES, record, 2);
+		writeUint16(MAX_RECORD_PAYLOAD_BYTES, record, 2);
 		ByteArrayInputStream in = new ByteArrayInputStream(record);
 		RecordReader reader = new RecordReaderImpl(in);
 		reader.readRecord();
@@ -57,7 +57,7 @@ public class RecordReaderImplTest extends BrambleTestCase {
 			throws Exception {
 		// Version 1, type 2, payload length MAX_RECORD_PAYLOAD_BYTES + 1
 		byte[] header = new byte[] {1, 2, 0, 0};
-		ByteUtils.writeUint16(MAX_RECORD_PAYLOAD_BYTES + 1, header, 2);
+		writeUint16(MAX_RECORD_PAYLOAD_BYTES + 1, header, 2);
 		ByteArrayInputStream in = new ByteArrayInputStream(header);
 		RecordReader reader = new RecordReaderImpl(in);
 		reader.readRecord();

bramble-core/src/test/java/org/briarproject/bramble/record/RecordWriterImplTest.java

@@ -3,7 +3,6 @@ package org.briarproject.bramble.record;
 import org.briarproject.bramble.api.record.Record;
 import org.briarproject.bramble.api.record.RecordWriter;
 import org.briarproject.bramble.test.BrambleTestCase;
-import org.briarproject.bramble.util.ByteUtils;
 import org.junit.Test;
 
 import java.io.ByteArrayOutputStream;
@@ -11,6 +10,7 @@ import java.io.ByteArrayOutputStream;
 import static org.briarproject.bramble.api.record.Record.MAX_RECORD_PAYLOAD_BYTES;
 import static org.briarproject.bramble.api.record.Record.RECORD_HEADER_BYTES;
 import static org.briarproject.bramble.test.TestUtils.getRandomBytes;
+import static org.briarproject.bramble.util.ByteUtils.readUint16;
 import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertEquals;
 
@@ -40,7 +40,7 @@ public class RecordWriterImplTest extends BrambleTestCase {
 		assertEquals(RECORD_HEADER_BYTES + payloadLength, written.length);
 		assertEquals(protocolVersion, written[0]);
 		assertEquals(recordType, written[1]);
-		assertEquals(payloadLength, ByteUtils.readUint16(written, 2));
+		assertEquals(payloadLength, readUint16(written, 2));
 		byte[] writtenPayload = new byte[payloadLength];
 		System.arraycopy(written, RECORD_HEADER_BYTES, writtenPayload, 0,
 				payloadLength);

bramble-core/src/test/java/org/briarproject/bramble/sync/SyncIntegrationTest.java

@@ -22,7 +22,6 @@ import org.briarproject.bramble.api.transport.StreamReaderFactory;
 import org.briarproject.bramble.api.transport.StreamWriter;
 import org.briarproject.bramble.api.transport.StreamWriterFactory;
 import org.briarproject.bramble.test.BrambleTestCase;
-import org.briarproject.bramble.test.TestUtils;
 import org.junit.Test;
 
 import java.io.ByteArrayInputStream;
@@ -37,6 +36,7 @@ import static org.briarproject.bramble.api.sync.SyncConstants.MAX_GROUP_DESCRIPT
 import static org.briarproject.bramble.api.transport.TransportConstants.PROTOCOL_VERSION;
 import static org.briarproject.bramble.api.transport.TransportConstants.TAG_LENGTH;
 import static org.briarproject.bramble.test.TestUtils.getClientId;
+import static org.briarproject.bramble.test.TestUtils.getSecretKey;
 import static org.briarproject.bramble.test.TestUtils.getTransportId;
 import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertEquals;
@@ -76,8 +76,8 @@ public class SyncIntegrationTest extends BrambleTestCase {
 		contactId = new ContactId(234);
 		transportId = getTransportId();
 		// Create the transport keys
-		tagKey = TestUtils.getSecretKey();
+		tagKey = getSecretKey();
-		headerKey = TestUtils.getSecretKey();
+		headerKey = getSecretKey();
 		streamNumber = 123;
 		// Create a group
 		ClientId clientId = getClientId();

bramble-core/src/test/java/org/briarproject/bramble/system/UnixSecureRandomSpiTest.java

@@ -2,7 +2,6 @@ package org.briarproject.bramble.system;
 
 import org.briarproject.bramble.api.Bytes;
 import org.briarproject.bramble.test.BrambleTestCase;
-import org.briarproject.bramble.test.TestUtils;
 import org.briarproject.bramble.util.IoUtils;
 import org.junit.After;
 import org.junit.Before;
@@ -15,6 +14,7 @@ import java.util.HashSet;
 import java.util.Set;
 
 import static org.briarproject.bramble.test.TestUtils.deleteTestDirectory;
+import static org.briarproject.bramble.test.TestUtils.getRandomBytes;
 import static org.briarproject.bramble.test.TestUtils.getTestDirectory;
 import static org.briarproject.bramble.util.OsUtils.isLinux;
 import static org.briarproject.bramble.util.OsUtils.isMac;
@@ -56,7 +56,7 @@ public class UnixSecureRandomSpiTest extends BrambleTestCase {
 		assertTrue(urandom.createNewFile());
 		assertEquals(0, urandom.length());
 		// Generate a seed
-		byte[] seed = TestUtils.getRandomBytes(SEED_BYTES);
+		byte[] seed = getRandomBytes(SEED_BYTES);
 		// Check that the engine writes the seed to the file
 		UnixSecureRandomSpi engine = new UnixSecureRandomSpi(RANDOM_DEVICE,
 				urandom);
@@ -72,7 +72,7 @@ public class UnixSecureRandomSpiTest extends BrambleTestCase {
 	@Test
 	public void testEngineNextBytesReadsFromRandomDevice() throws Exception {
 		// Generate some entropy
-		byte[] entropy = TestUtils.getRandomBytes(SEED_BYTES);
+		byte[] entropy = getRandomBytes(SEED_BYTES);
 		// Write the entropy to a file
 		File urandom = new File(testDir, "urandom");
 		if (urandom.exists()) assertTrue(urandom.delete());
@@ -93,7 +93,7 @@ public class UnixSecureRandomSpiTest extends BrambleTestCase {
 	@Test
 	public void testEngineGenerateSeedReadsFromRandomDevice() throws Exception {
 		// Generate some entropy
-		byte[] entropy = TestUtils.getRandomBytes(SEED_BYTES);
+		byte[] entropy = getRandomBytes(SEED_BYTES);
 		// Write the entropy to a file
 		File urandom = new File(testDir, "urandom");
 		if (urandom.exists()) assertTrue(urandom.delete());

bramble-core/src/test/java/org/briarproject/bramble/transport/ReorderingWindowTest.java

@@ -1,7 +1,6 @@
 package org.briarproject.bramble.transport;
 
 import org.briarproject.bramble.test.BrambleTestCase;
-import org.briarproject.bramble.test.TestUtils;
 import org.briarproject.bramble.transport.ReorderingWindow.Change;
 import org.junit.Test;
 
@@ -9,6 +8,7 @@ import java.util.Arrays;
 import java.util.Collections;
 
 import static org.briarproject.bramble.api.transport.TransportConstants.REORDERING_WINDOW_SIZE;
+import static org.briarproject.bramble.test.TestUtils.getRandomBytes;
 import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertEquals;
 
@@ -19,7 +19,7 @@ public class ReorderingWindowTest extends BrambleTestCase {
 	@Test
 	public void testBitmapConversion() {
 		for (int i = 0; i < 1000; i++) {
-			byte[] bitmap = TestUtils.getRandomBytes(BITMAP_BYTES);
+			byte[] bitmap = getRandomBytes(BITMAP_BYTES);
 			ReorderingWindow window = new ReorderingWindow(0L, bitmap);
 			assertArrayEquals(bitmap, window.getBitmap());
 		}

bramble-core/src/test/java/org/briarproject/bramble/transport/StreamReaderWriterIntegrationTest.java

@@ -3,7 +3,6 @@ package org.briarproject.bramble.transport;
 import org.briarproject.bramble.api.crypto.StreamDecrypter;
 import org.briarproject.bramble.api.crypto.StreamEncrypter;
 import org.briarproject.bramble.test.BrambleTestCase;
-import org.briarproject.bramble.test.TestUtils;
 import org.junit.Test;
 
 import java.io.ByteArrayInputStream;
@@ -16,6 +15,7 @@ import static org.briarproject.bramble.api.transport.TransportConstants.FRAME_HE
 import static org.briarproject.bramble.api.transport.TransportConstants.MAC_LENGTH;
 import static org.briarproject.bramble.api.transport.TransportConstants.STREAM_HEADER_LENGTH;
 import static org.briarproject.bramble.api.transport.TransportConstants.TAG_LENGTH;
+import static org.briarproject.bramble.test.TestUtils.getRandomBytes;
 import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertEquals;
 
@@ -24,10 +24,10 @@ public class StreamReaderWriterIntegrationTest extends BrambleTestCase {
 	@Test
 	public void testWriteAndRead() throws Exception {
 		// Generate a random tag
-		byte[] tag = TestUtils.getRandomBytes(TAG_LENGTH);
+		byte[] tag = getRandomBytes(TAG_LENGTH);
 		// Generate two frames with random payloads
-		byte[] payload1 = TestUtils.getRandomBytes(123);
+		byte[] payload1 = getRandomBytes(123);
-		byte[] payload2 = TestUtils.getRandomBytes(321);
+		byte[] payload2 = getRandomBytes(321);
 		// Write the tag and the frames
 		ByteArrayOutputStream out = new ByteArrayOutputStream();
 		StreamEncrypter encrypter = new TestStreamEncrypter(out, tag);

bramble-core/src/test/java/org/briarproject/bramble/transport/TestStreamDecrypter.java

@@ -2,7 +2,6 @@ package org.briarproject.bramble.transport;
 
 import org.briarproject.bramble.api.crypto.StreamDecrypter;
 import org.briarproject.bramble.api.nullsafety.NotNullByDefault;
-import org.briarproject.bramble.util.ByteUtils;
 
 import java.io.EOFException;
 import java.io.IOException;
@@ -13,6 +12,7 @@ import static org.briarproject.bramble.api.transport.TransportConstants.MAC_LENG
 import static org.briarproject.bramble.api.transport.TransportConstants.MAX_FRAME_LENGTH;
 import static org.briarproject.bramble.api.transport.TransportConstants.STREAM_HEADER_LENGTH;
 import static org.briarproject.bramble.util.ByteUtils.INT_16_BYTES;
+import static org.briarproject.bramble.util.ByteUtils.readUint16;
 
 @NotNullByDefault
 class TestStreamDecrypter implements StreamDecrypter {
@@ -38,8 +38,8 @@ class TestStreamDecrypter implements StreamDecrypter {
 			offset += read;
 		}
 		finalFrame = (frame[0] & 0x80) == 0x80;
-		int payloadLength = ByteUtils.readUint16(frame, 0) & 0x7FFF;
+		int payloadLength = readUint16(frame, 0) & 0x7FFF;
-		int paddingLength = ByteUtils.readUint16(frame, INT_16_BYTES);
+		int paddingLength = readUint16(frame, INT_16_BYTES);
 		int frameLength = FRAME_HEADER_LENGTH + payloadLength + paddingLength
 				+ MAC_LENGTH;
 		while (offset < frameLength) {

bramble-core/src/test/java/org/briarproject/bramble/transport/TestStreamEncrypter.java

@@ -2,7 +2,6 @@ package org.briarproject.bramble.transport;
 
 import org.briarproject.bramble.api.crypto.StreamEncrypter;
 import org.briarproject.bramble.api.nullsafety.NotNullByDefault;
-import org.briarproject.bramble.util.ByteUtils;
 
 import java.io.IOException;
 import java.io.OutputStream;
@@ -11,6 +10,7 @@ import static org.briarproject.bramble.api.transport.TransportConstants.FRAME_HE
 import static org.briarproject.bramble.api.transport.TransportConstants.MAC_LENGTH;
 import static org.briarproject.bramble.api.transport.TransportConstants.STREAM_HEADER_LENGTH;
 import static org.briarproject.bramble.util.ByteUtils.INT_16_BYTES;
+import static org.briarproject.bramble.util.ByteUtils.writeUint16;
 
 @NotNullByDefault
 class TestStreamEncrypter implements StreamEncrypter {
@@ -30,8 +30,8 @@ class TestStreamEncrypter implements StreamEncrypter {
 			int paddingLength, boolean finalFrame) throws IOException {
 		if (writeTagAndHeader) writeTagAndHeader();
 		byte[] frameHeader = new byte[FRAME_HEADER_LENGTH];
-		ByteUtils.writeUint16(payloadLength, frameHeader, 0);
+		writeUint16(payloadLength, frameHeader, 0);
-		ByteUtils.writeUint16(paddingLength, frameHeader, INT_16_BYTES);
+		writeUint16(paddingLength, frameHeader, INT_16_BYTES);
 		if (finalFrame) frameHeader[0] |= 0x80;
 		out.write(frameHeader);
 		out.write(payload, 0, payloadLength);

bramble-core/src/test/java/org/briarproject/bramble/transport/TransportKeyManagerImplTest.java

@@ -16,7 +16,6 @@ import org.briarproject.bramble.api.transport.TransportKeys;
 import org.briarproject.bramble.test.BrambleMockTestCase;
 import org.briarproject.bramble.test.DbExpectations;
 import org.briarproject.bramble.test.RunAction;
-import org.briarproject.bramble.test.TestUtils;
 import org.hamcrest.Description;
 import org.jmock.Expectations;
 import org.jmock.api.Action;
@@ -37,6 +36,7 @@ import static org.briarproject.bramble.api.transport.TransportConstants.MAX_CLOC
 import static org.briarproject.bramble.api.transport.TransportConstants.PROTOCOL_VERSION;
 import static org.briarproject.bramble.api.transport.TransportConstants.REORDERING_WINDOW_SIZE;
 import static org.briarproject.bramble.api.transport.TransportConstants.TAG_LENGTH;
+import static org.briarproject.bramble.test.TestUtils.getSecretKey;
 import static org.briarproject.bramble.test.TestUtils.getTransportId;
 import static org.briarproject.bramble.util.ByteUtils.MAX_32_BIT_UNSIGNED;
 import static org.junit.Assert.assertEquals;
@@ -62,9 +62,9 @@ public class TransportKeyManagerImplTest extends BrambleMockTestCase {
 	private final ContactId contactId1 = new ContactId(234);
 	private final KeySetId keySetId = new KeySetId(345);
 	private final KeySetId keySetId1 = new KeySetId(456);
-	private final SecretKey tagKey = TestUtils.getSecretKey();
+	private final SecretKey tagKey = getSecretKey();
-	private final SecretKey headerKey = TestUtils.getSecretKey();
+	private final SecretKey headerKey = getSecretKey();
-	private final SecretKey masterKey = TestUtils.getSecretKey();
+	private final SecretKey masterKey = getSecretKey();
 	private final Random random = new Random();
 
 	@Test

bramble-core/src/test/java/org/briarproject/bramble/util/ByteUtilsTest.java

@@ -5,6 +5,15 @@ import org.junit.Test;
 
 import static org.briarproject.bramble.util.ByteUtils.MAX_16_BIT_UNSIGNED;
 import static org.briarproject.bramble.util.ByteUtils.MAX_32_BIT_UNSIGNED;
+import static org.briarproject.bramble.util.ByteUtils.readUint;
+import static org.briarproject.bramble.util.ByteUtils.readUint16;
+import static org.briarproject.bramble.util.ByteUtils.readUint32;
+import static org.briarproject.bramble.util.ByteUtils.readUint64;
+import static org.briarproject.bramble.util.ByteUtils.writeUint16;
+import static org.briarproject.bramble.util.ByteUtils.writeUint32;
+import static org.briarproject.bramble.util.ByteUtils.writeUint64;
+import static org.briarproject.bramble.util.StringUtils.fromHexString;
+import static org.briarproject.bramble.util.StringUtils.toHexString;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.fail;
 
@@ -12,107 +21,107 @@ public class ByteUtilsTest extends BrambleTestCase {
 
 	@Test
 	public void testReadUint16() {
-		byte[] b = StringUtils.fromHexString("00000000");
+		byte[] b = fromHexString("00000000");
-		assertEquals(0, ByteUtils.readUint16(b, 1));
+		assertEquals(0, readUint16(b, 1));
-		b = StringUtils.fromHexString("00000100");
+		b = fromHexString("00000100");
-		assertEquals(1, ByteUtils.readUint16(b, 1));
+		assertEquals(1, readUint16(b, 1));
-		b = StringUtils.fromHexString("007FFF00");
+		b = fromHexString("007FFF00");
-		assertEquals(Short.MAX_VALUE, ByteUtils.readUint16(b, 1));
+		assertEquals(Short.MAX_VALUE, readUint16(b, 1));
-		b = StringUtils.fromHexString("00FFFF00");
+		b = fromHexString("00FFFF00");
-		assertEquals(65535, ByteUtils.readUint16(b, 1));
+		assertEquals(65535, readUint16(b, 1));
 	}
 
 	@Test(expected = IllegalArgumentException.class)
 	public void testReadUint16ValidatesArguments1() {
-		ByteUtils.readUint16(new byte[1], 0);
+		readUint16(new byte[1], 0);
 	}
 
 	@Test(expected = IllegalArgumentException.class)
 	public void testReadUint16ValidatesArguments2() {
-		ByteUtils.readUint16(new byte[2], 1);
+		readUint16(new byte[2], 1);
 	}
 
 	@Test
 	public void testReadUint32() {
-		byte[] b = StringUtils.fromHexString("000000000000");
+		byte[] b = fromHexString("000000000000");
-		assertEquals(0, ByteUtils.readUint32(b, 1));
+		assertEquals(0, readUint32(b, 1));
-		b = StringUtils.fromHexString("000000000100");
+		b = fromHexString("000000000100");
-		assertEquals(1, ByteUtils.readUint32(b, 1));
+		assertEquals(1, readUint32(b, 1));
-		b = StringUtils.fromHexString("007FFFFFFF00");
+		b = fromHexString("007FFFFFFF00");
-		assertEquals(Integer.MAX_VALUE, ByteUtils.readUint32(b, 1));
+		assertEquals(Integer.MAX_VALUE, readUint32(b, 1));
-		b = StringUtils.fromHexString("00FFFFFFFF00");
+		b = fromHexString("00FFFFFFFF00");
-		assertEquals(4294967295L, ByteUtils.readUint32(b, 1));
+		assertEquals(4294967295L, readUint32(b, 1));
 	}
 
 	@Test(expected = IllegalArgumentException.class)
 	public void testReadUint32ValidatesArguments1() {
-		ByteUtils.readUint32(new byte[3], 0);
+		readUint32(new byte[3], 0);
 	}
 
 	@Test(expected = IllegalArgumentException.class)
 	public void testReadUint32ValidatesArguments2() {
-		ByteUtils.readUint32(new byte[4], 1);
+		readUint32(new byte[4], 1);
 	}
 
 	@Test
 	public void testReadUint64() {
-		byte[] b = StringUtils.fromHexString("00000000000000000000");
+		byte[] b = fromHexString("00000000000000000000");
-		assertEquals(0L, ByteUtils.readUint64(b, 1));
+		assertEquals(0L, readUint64(b, 1));
-		b = StringUtils.fromHexString("00000000000000000100");
+		b = fromHexString("00000000000000000100");
-		assertEquals(1L, ByteUtils.readUint64(b, 1));
+		assertEquals(1L, readUint64(b, 1));
-		b = StringUtils.fromHexString("007FFFFFFFFFFFFFFF00");
+		b = fromHexString("007FFFFFFFFFFFFFFF00");
-		assertEquals(Long.MAX_VALUE, ByteUtils.readUint64(b, 1));
+		assertEquals(Long.MAX_VALUE, readUint64(b, 1));
-		b = StringUtils.fromHexString("00800000000000000000");
+		b = fromHexString("00800000000000000000");
-		assertEquals(Long.MIN_VALUE, ByteUtils.readUint64(b, 1));
+		assertEquals(Long.MIN_VALUE, readUint64(b, 1));
-		b = StringUtils.fromHexString("00FFFFFFFFFFFFFFFF00");
+		b = fromHexString("00FFFFFFFFFFFFFFFF00");
-		assertEquals(-1L, ByteUtils.readUint64(b, 1));
+		assertEquals(-1L, readUint64(b, 1));
 	}
 
 	@Test(expected = IllegalArgumentException.class)
 	public void testReadUint64ValidatesArguments1() {
-		ByteUtils.readUint64(new byte[7], 0);
+		readUint64(new byte[7], 0);
 	}
 
 	@Test(expected = IllegalArgumentException.class)
 	public void testReadUint64ValidatesArguments2() {
-		ByteUtils.readUint64(new byte[8], 1);
+		readUint64(new byte[8], 1);
 	}
 
 	@Test
 	public void testWriteUint16() {
 		byte[] b = new byte[4];
-		ByteUtils.writeUint16(0, b, 1);
+		writeUint16(0, b, 1);
-		assertEquals("00000000", StringUtils.toHexString(b));
+		assertEquals("00000000", toHexString(b));
-		ByteUtils.writeUint16(1, b, 1);
+		writeUint16(1, b, 1);
-		assertEquals("00000100", StringUtils.toHexString(b));
+		assertEquals("00000100", toHexString(b));
-		ByteUtils.writeUint16(Short.MAX_VALUE, b, 1);
+		writeUint16(Short.MAX_VALUE, b, 1);
-		assertEquals("007FFF00", StringUtils.toHexString(b));
+		assertEquals("007FFF00", toHexString(b));
-		ByteUtils.writeUint16(MAX_16_BIT_UNSIGNED, b, 1);
+		writeUint16(MAX_16_BIT_UNSIGNED, b, 1);
-		assertEquals("00FFFF00", StringUtils.toHexString(b));
+		assertEquals("00FFFF00", toHexString(b));
 	}
 
 	@Test
 	public void testWriteUint16ValidatesArguments() {
 		try {
-			ByteUtils.writeUint16(0, new byte[1], 0);
+			writeUint16(0, new byte[1], 0);
 			fail();
 		} catch (IllegalArgumentException expected) {
 			// Expected
 		}
 		try {
-			ByteUtils.writeUint16(0, new byte[2], 1);
+			writeUint16(0, new byte[2], 1);
 			fail();
 		} catch (IllegalArgumentException expected) {
 			// Expected
 		}
 		try {
-			ByteUtils.writeUint16(-1, new byte[2], 0);
+			writeUint16(-1, new byte[2], 0);
 			fail();
 		} catch (IllegalArgumentException expected) {
 			// Expected
 		}
 		try {
-			ByteUtils.writeUint16(MAX_16_BIT_UNSIGNED + 1, new byte[2], 0);
+			writeUint16(MAX_16_BIT_UNSIGNED + 1, new byte[2], 0);
 			fail();
 		} catch (IllegalArgumentException expected) {
 			// Expected
@@ -122,38 +131,38 @@ public class ByteUtilsTest extends BrambleTestCase {
 	@Test
 	public void testWriteUint32() {
 		byte[] b = new byte[6];
-		ByteUtils.writeUint32(0, b, 1);
+		writeUint32(0, b, 1);
-		assertEquals("000000000000", StringUtils.toHexString(b));
+		assertEquals("000000000000", toHexString(b));
-		ByteUtils.writeUint32(1, b, 1);
+		writeUint32(1, b, 1);
-		assertEquals("000000000100", StringUtils.toHexString(b));
+		assertEquals("000000000100", toHexString(b));
-		ByteUtils.writeUint32(Integer.MAX_VALUE, b, 1);
+		writeUint32(Integer.MAX_VALUE, b, 1);
-		assertEquals("007FFFFFFF00", StringUtils.toHexString(b));
+		assertEquals("007FFFFFFF00", toHexString(b));
-		ByteUtils.writeUint32(MAX_32_BIT_UNSIGNED, b, 1);
+		writeUint32(MAX_32_BIT_UNSIGNED, b, 1);
-		assertEquals("00FFFFFFFF00", StringUtils.toHexString(b));
+		assertEquals("00FFFFFFFF00", toHexString(b));
 	}
 
 	@Test
 	public void testWriteUint32ValidatesArguments() {
 		try {
-			ByteUtils.writeUint32(0, new byte[3], 0);
+			writeUint32(0, new byte[3], 0);
 			fail();
 		} catch (IllegalArgumentException expected) {
 			// Expected
 		}
 		try {
-			ByteUtils.writeUint32(0, new byte[4], 1);
+			writeUint32(0, new byte[4], 1);
 			fail();
 		} catch (IllegalArgumentException expected) {
 			// Expected
 		}
 		try {
-			ByteUtils.writeUint32(-1, new byte[4], 0);
+			writeUint32(-1, new byte[4], 0);
 			fail();
 		} catch (IllegalArgumentException expected) {
 			// Expected
 		}
 		try {
-			ByteUtils.writeUint32(MAX_32_BIT_UNSIGNED + 1, new byte[4], 0);
+			writeUint32(MAX_32_BIT_UNSIGNED + 1, new byte[4], 0);
 			fail();
 		} catch (IllegalArgumentException expected) {
 			// Expected
@@ -163,30 +172,30 @@ public class ByteUtilsTest extends BrambleTestCase {
 	@Test
 	public void testWriteUint64() {
 		byte[] b = new byte[10];
-		ByteUtils.writeUint64(0, b, 1);
+		writeUint64(0, b, 1);
-		assertEquals("00000000000000000000", StringUtils.toHexString(b));
+		assertEquals("00000000000000000000", toHexString(b));
-		ByteUtils.writeUint64(1, b, 1);
+		writeUint64(1, b, 1);
-		assertEquals("00000000000000000100", StringUtils.toHexString(b));
+		assertEquals("00000000000000000100", toHexString(b));
-		ByteUtils.writeUint64(Long.MAX_VALUE, b, 1);
+		writeUint64(Long.MAX_VALUE, b, 1);
-		assertEquals("007FFFFFFFFFFFFFFF00", StringUtils.toHexString(b));
+		assertEquals("007FFFFFFFFFFFFFFF00", toHexString(b));
 	}
 
 	@Test
 	public void testWriteUint64ValidatesArguments() {
 		try {
-			ByteUtils.writeUint64(0, new byte[7], 0);
+			writeUint64(0, new byte[7], 0);
 			fail();
 		} catch (IllegalArgumentException expected) {
 			// Expected
 		}
 		try {
-			ByteUtils.writeUint64(0, new byte[8], 1);
+			writeUint64(0, new byte[8], 1);
 			fail();
 		} catch (IllegalArgumentException expected) {
 			// Expected
 		}
 		try {
-			ByteUtils.writeUint64(-1, new byte[8], 0);
+			writeUint64(-1, new byte[8], 0);
 			fail();
 		} catch (IllegalArgumentException expected) {
 			// Expected
@@ -198,13 +207,13 @@ public class ByteUtilsTest extends BrambleTestCase {
 		byte[] b = new byte[1];
 		b[0] = (byte) 128;
 		for (int i = 0; i < 8; i++) {
-			assertEquals(1 << i, ByteUtils.readUint(b, i + 1));
+			assertEquals(1 << i, readUint(b, i + 1));
 		}
 		b = new byte[2];
 		for (int i = 0; i < 65535; i++) {
-			ByteUtils.writeUint16(i, b, 0);
+			writeUint16(i, b, 0);
-			assertEquals(i, ByteUtils.readUint(b, 16));
+			assertEquals(i, readUint(b, 16));
-			assertEquals(i >> 1, ByteUtils.readUint(b, 15));
+			assertEquals(i >> 1, readUint(b, 15));
 		}
 	}
 }

bramble-core/src/test/java/org/briarproject/bramble/util/StringUtilsTest.java

@@ -3,6 +3,13 @@ package org.briarproject.bramble.util;
 import org.briarproject.bramble.test.BrambleTestCase;
 import org.junit.Test;
 
+import static org.briarproject.bramble.util.StringUtils.fromHexString;
+import static org.briarproject.bramble.util.StringUtils.fromUtf8;
+import static org.briarproject.bramble.util.StringUtils.macToBytes;
+import static org.briarproject.bramble.util.StringUtils.macToString;
+import static org.briarproject.bramble.util.StringUtils.toHexString;
+import static org.briarproject.bramble.util.StringUtils.toUtf8;
+import static org.briarproject.bramble.util.StringUtils.truncateUtf8;
 import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertSame;
@@ -16,22 +23,22 @@ public class StringUtilsTest extends BrambleTestCase {
 				0x0A, 0x0B, 0x0C, 0x0D, 0x0E, (byte) 0xFF
 		};
 		String expected = "000102037F800A0B0C0D0EFF";
-		assertEquals(expected, StringUtils.toHexString(b));
+		assertEquals(expected, toHexString(b));
 	}
 
 	@Test
 	public void testToHexStringEmptyInput() {
-		assertEquals("", StringUtils.toHexString(new byte[0]));
+		assertEquals("", toHexString(new byte[0]));
 	}
 
 	@Test(expected = IllegalArgumentException.class)
 	public void testFromHexStringRejectsInvalidLength() {
-		StringUtils.fromHexString("12345");
+		fromHexString("12345");
 	}
 
 	@Test(expected = IllegalArgumentException.class)
 	public void testFromHexStringRejectsInvalidCharacter() {
-		StringUtils.fromHexString("ABCDEFGH");
+		fromHexString("ABCDEFGH");
 	}
 
 	@Test
@@ -41,7 +48,7 @@ public class StringUtilsTest extends BrambleTestCase {
 				0x00, 0x01, 0x02, 0x03, 0x7F, (byte) 0x80,
 				0x0A, 0x0B, 0x0C, 0x0D, 0x0E, (byte) 0xFF
 		};
-		assertArrayEquals(expected, StringUtils.fromHexString(s));
+		assertArrayEquals(expected, fromHexString(s));
 	}
 
 	@Test
@@ -51,12 +58,12 @@ public class StringUtilsTest extends BrambleTestCase {
 				0x00, 0x01, 0x02, 0x03, 0x7F, (byte) 0x80,
 				0x0A, 0x0B, 0x0C, 0x0D, 0x0E, (byte) 0xFF
 		};
-		assertArrayEquals(expected, StringUtils.fromHexString(s));
+		assertArrayEquals(expected, fromHexString(s));
 	}
 
 	@Test
 	public void testFromHexStringEmptyInput() {
-		assertArrayEquals(new byte[0], StringUtils.fromHexString(""));
+		assertArrayEquals(new byte[0], fromHexString(""));
 	}
 
 	@Test
@@ -64,7 +71,7 @@ public class StringUtilsTest extends BrambleTestCase {
 		// The Unicode null character should be encoded as a single null byte,
 		// not as two bytes as in CESU-8 and modified UTF-8
 		String s = "\u0000";
-		assertArrayEquals(new byte[1], StringUtils.toUtf8(s));
+		assertArrayEquals(new byte[1], toUtf8(s));
 	}
 
 	@Test
@@ -77,18 +84,18 @@ public class StringUtilsTest extends BrambleTestCase {
 				(byte) 0xC8, (byte) 0x85, // U+0205
 				(byte) 0xF0, (byte) 0x90, (byte) 0x90, (byte) 0x80 // U+10400
 		};
-		assertArrayEquals(expected, StringUtils.toUtf8(s));
+		assertArrayEquals(expected, toUtf8(s));
 	}
 
 	@Test
 	public void testToUtf8EmptyInput() {
-		assertArrayEquals(new byte[0], StringUtils.toUtf8(""));
+		assertArrayEquals(new byte[0], toUtf8(""));
 	}
 
 	@Test
 	public void testFromUtf8AcceptsNullCharacterUsingStandardUtf8() {
 		// The UTF-8 encoding of the null character is valid
-		assertEquals("\u0000", StringUtils.fromUtf8(new byte[1]));
+		assertEquals("\u0000", fromUtf8(new byte[1]));
 	}
 
 	@Test
@@ -100,7 +107,7 @@ public class StringUtilsTest extends BrambleTestCase {
 		};
 		// Conversion should ignore the invalid character and return the rest
 		String expected = "\u0205";
-		assertEquals(expected, StringUtils.fromUtf8(b));
+		assertEquals(expected, fromUtf8(b));
 	}
 
 	@Test
@@ -112,7 +119,7 @@ public class StringUtilsTest extends BrambleTestCase {
 				(byte) 0xC8, (byte) 0x85 // U+0205
 		};
 		String expected = "\uD801\uDC00\u0205"; // Surrogate pair
-		assertEquals(expected, StringUtils.fromUtf8(b));
+		assertEquals(expected, fromUtf8(b));
 	}
 
 	@Test
@@ -126,102 +133,102 @@ public class StringUtilsTest extends BrambleTestCase {
 		};
 		// Conversion should ignore the invalid character and return the rest
 		String expected = "\u0205";
-		assertEquals(expected, StringUtils.fromUtf8(b));
+		assertEquals(expected, fromUtf8(b));
 	}
 
 	@Test
 	public void testFromUtf8EmptyInput() {
-		assertEquals("", StringUtils.fromUtf8(new byte[0]));
+		assertEquals("", fromUtf8(new byte[0]));
 	}
 
 	@Test
 	public void testTruncateUtf8ReturnsArgumentIfNotTruncated() {
 		String s = "Hello";
-		assertSame(s, StringUtils.truncateUtf8(s, 5));
+		assertSame(s, truncateUtf8(s, 5));
 	}
 
 	@Test
 	public void testTruncateUtf8ChecksUtf8LengthNotStringLength() {
 		String s = "H\u0205llo";
 		assertEquals(5, s.length());
-		assertEquals(6, StringUtils.toUtf8(s).length);
+		assertEquals(6, toUtf8(s).length);
 		String expected = "H\u0205ll"; // Sixth byte removed
-		assertEquals(expected, StringUtils.truncateUtf8(s, 5));
+		assertEquals(expected, truncateUtf8(s, 5));
 	}
 
 	@Test
 	public void testTruncateUtf8RemovesTruncatedCharacter() {
 		String s = "\u0205\u0205"; // String requires four bytes
 		String expected = "\u0205"; // Partial character removed
-		String truncated = StringUtils.truncateUtf8(s, 3);
+		String truncated = truncateUtf8(s, 3);
 		assertEquals(expected, truncated);
 		// Converting the truncated string should not exceed the max length
-		assertEquals(2, StringUtils.toUtf8(truncated).length);
+		assertEquals(2, toUtf8(truncated).length);
 	}
 
 	@Test
 	public void testTruncateUtf8RemovesTruncatedSurrogatePair() {
 		String s = "\u0205\uD801\uDC00"; // String requires six bytes
 		String expected = "\u0205"; // Partial character removed
-		String truncated = StringUtils.truncateUtf8(s, 3);
+		String truncated = truncateUtf8(s, 3);
 		assertEquals(expected, truncated);
 		// Converting the truncated string should not exceed the max length
-		assertEquals(2, StringUtils.toUtf8(truncated).length);
+		assertEquals(2, toUtf8(truncated).length);
 	}
 
 	@Test
 	public void testTruncateUtf8EmptyInput() {
-		assertEquals("", StringUtils.truncateUtf8("", 123));
+		assertEquals("", truncateUtf8("", 123));
 	}
 
 	@Test(expected = IllegalArgumentException.class)
 	public void testMacToBytesRejectsShortMac() {
-		StringUtils.macToBytes("00:00:00:00:00");
+		macToBytes("00:00:00:00:00");
 	}
 
 	@Test(expected = IllegalArgumentException.class)
 	public void testMacToBytesRejectsLongMac() {
-		StringUtils.macToBytes("00:00:00:00:00:00:00");
+		macToBytes("00:00:00:00:00:00:00");
 	}
 
 	@Test(expected = IllegalArgumentException.class)
 	public void testMacToBytesRejectsInvalidCharacter() {
-		StringUtils.macToBytes("00:00:00:00:00:0g");
+		macToBytes("00:00:00:00:00:0g");
 	}
 
 	@Test(expected = IllegalArgumentException.class)
 	public void testMacToBytesRejectsInvalidFormat() {
-		StringUtils.macToBytes("0:000:00:00:00:00");
+		macToBytes("0:000:00:00:00:00");
 	}
 
 	@Test
 	public void testMacToBytesUpperCase() {
 		byte[] expected = new byte[] {0x0A, 0x1B, 0x2C, 0x3D, 0x4E, 0x5F};
 		String mac = "0A:1B:2C:3D:4E:5F";
-		assertArrayEquals(expected, StringUtils.macToBytes(mac));
+		assertArrayEquals(expected, macToBytes(mac));
 	}
 
 	@Test
 	public void testMacToBytesLowerCase() {
 		byte[] expected = new byte[] {0x0A, 0x1B, 0x2C, 0x3D, 0x4E, 0x5F};
 		String mac = "0a:1b:2c:3d:4e:5f";
-		assertArrayEquals(expected, StringUtils.macToBytes(mac));
+		assertArrayEquals(expected, macToBytes(mac));
 	}
 
 	@Test(expected = IllegalArgumentException.class)
 	public void testMacToStringRejectsShortMac() {
-		StringUtils.macToString(new byte[5]);
+		macToString(new byte[5]);
 	}
 
 	@Test(expected = IllegalArgumentException.class)
 	public void testMacToStringRejectsLongMac() {
-		StringUtils.macToString(new byte[7]);
+		macToString(new byte[7]);
 	}
 
 	@Test
 	public void testMacToString() {
 		byte[] mac = new byte[] {0x0a, 0x1b, 0x2c, 0x3d, 0x4e, 0x5f};
 		String expected = "0A:1B:2C:3D:4E:5F";
-		assertEquals(expected, StringUtils.macToString(mac));
+		assertEquals(expected, macToString(mac));
 	}
 }

bramble-java/src/main/java/org/briarproject/bramble/lifecycle/WindowsShutdownManagerImpl.java

@@ -27,6 +27,7 @@ import javax.annotation.concurrent.ThreadSafe;
 import static com.sun.jna.Library.OPTION_FUNCTION_MAPPER;
 import static com.sun.jna.Library.OPTION_TYPE_MAPPER;
 import static java.util.logging.Level.WARNING;
+import static java.util.logging.Logger.getLogger;
 import static org.briarproject.bramble.util.LogUtils.logException;
 import static org.briarproject.bramble.util.OsUtils.isWindows;
 
@@ -35,7 +36,7 @@ import static org.briarproject.bramble.util.OsUtils.isWindows;
 class WindowsShutdownManagerImpl extends ShutdownManagerImpl {
 
 	private static final Logger LOG =
-			Logger.getLogger(WindowsShutdownManagerImpl.class.getName());
+			getLogger(WindowsShutdownManagerImpl.class.getName());
 
 	private static final int WM_QUERYENDSESSION = 17;
 	private static final int GWL_WNDPROC = -4;

bramble-java/src/main/java/org/briarproject/bramble/network/JavaNetworkManager.java

@@ -16,6 +16,7 @@ import static java.net.NetworkInterface.getNetworkInterfaces;
 import static java.util.Collections.list;
 import static java.util.logging.Level.INFO;
 import static java.util.logging.Level.WARNING;
+import static java.util.logging.Logger.getLogger;
 import static org.briarproject.bramble.util.LogUtils.logException;
 
 @MethodsNotNullByDefault
@@ -23,7 +24,7 @@ import static org.briarproject.bramble.util.LogUtils.logException;
 class JavaNetworkManager implements NetworkManager {
 
 	private static final Logger LOG =
-			Logger.getLogger(JavaNetworkManager.class.getName());
+			getLogger(JavaNetworkManager.class.getName());
 
 	@Inject
 	JavaNetworkManager() {