From d95eddea6b497df3cc23eefaa3fff2156e161c4b Mon Sep 17 00:00:00 2001
From: Janne Koschinski <janne@kuschku.de>
Date: Thu, 17 Jan 2019 13:18:11 +0100
Subject: [PATCH] Switched to proper unsigned data types

---
 .../defaults/DefaultNetworkServer.kt          |  2 +-
 .../quasseldroid/service/BacklogRequester.kt  |  2 +-
 .../quasseldroid/ui/chat/ChatActivity.kt      | 19 ++---
 .../chat/buffers/BufferViewConfigFragment.kt  |  6 +-
 .../ui/chat/messages/MessageAdapter.kt        |  2 +-
 .../network/NetworkBaseFragment.kt            | 11 ++-
 .../networkserver/NetworkServerFragment.kt    | 18 +++--
 .../setup/network/NetworkSetupNetworkSlide.kt | 17 ++--
 .../ui/setup/user/UserSetupNetworkSlide.kt    | 17 ++--
 .../de/kuschku/libquassel/protocol/Message.kt | 56 ++++++-------
 .../de/kuschku/libquassel/protocol/QType.kt   |  3 +-
 .../de/kuschku/libquassel/protocol/QTypes.kt  |  5 --
 .../de/kuschku/libquassel/protocol/Type.kt    |  8 +-
 .../message/ClientInitAckSerializer.kt        |  4 +-
 .../protocol/message/ClientInitSerializer.kt  |  4 +-
 .../DccConfig_IpDetectionModeSerializer.kt    |  4 +-
 .../DccConfig_PortSelectionModeSerializer.kt  |  4 +-
 .../serializer/ProtocolInfoSerializer.kt      |  4 +-
 .../primitive/serializer/UByteSerializer.kt   | 34 ++++++++
 .../primitive/serializer/UIntSerializer.kt    | 17 +++-
 .../primitive/serializer/ULongSerializer.kt   | 34 ++++++++
 .../primitive/serializer/UShortSerializer.kt  | 34 ++++++++
 .../kuschku/libquassel/quassel/BufferInfo.kt  | 27 ++++---
 .../libquassel/quassel/LegacyFeature.kt       | 35 +++++----
 .../libquassel/quassel/ProtocolFeature.kt     |  9 ++-
 .../quassel/syncables/BufferViewConfig.kt     |  4 +-
 .../libquassel/quassel/syncables/DccConfig.kt |  4 +-
 .../libquassel/quassel/syncables/Network.kt   | 16 ++--
 .../syncables/interfaces/IDccConfig.kt        | 13 ++--
 .../quassel/syncables/interfaces/INetwork.kt  | 33 ++++----
 .../de/kuschku/libquassel/util/flag/Flag.kt   | 54 ++++++++-----
 .../kuschku/libquassel/util/flag/LongFlag.kt  | 78 +++++++++++--------
 .../kuschku/libquassel/util/flag/ShortFlag.kt | 65 +++++++++-------
 .../util/helpers/CollectionHelper.kt          | 50 ++++++++++++
 .../quassel/syncables/AliasManagerTest.kt     | 10 ++-
 .../quassel/syncables/BufferViewConfigTest.kt | 18 +++--
 .../syncables/HighlightRuleManagerTest.kt     | 10 ++-
 .../quassel/syncables/IdentityTest.kt         | 16 ++--
 .../syncables/IgnoreListManagerTest.kt        | 10 ++-
 .../quassel/syncables/NetworkConfigTest.kt    | 33 ++++----
 .../quassel/syncables/NetworkTest.kt          | 26 ++++---
 .../syncables/interfaces/INetworkInfoTest.kt  |  5 +-
 .../kuschku/libquassel/util/RandomHelpers.kt  | 14 ++--
 43 files changed, 547 insertions(+), 288 deletions(-)
 create mode 100644 lib/src/main/java/de/kuschku/libquassel/protocol/primitive/serializer/UByteSerializer.kt
 rename app/src/main/java/de/kuschku/quasseldroid/util/irc/IrcPorts.kt => lib/src/main/java/de/kuschku/libquassel/protocol/primitive/serializer/UIntSerializer.kt (59%)
 create mode 100644 lib/src/main/java/de/kuschku/libquassel/protocol/primitive/serializer/ULongSerializer.kt
 create mode 100644 lib/src/main/java/de/kuschku/libquassel/protocol/primitive/serializer/UShortSerializer.kt
 create mode 100644 lib/src/main/java/de/kuschku/libquassel/util/helpers/CollectionHelper.kt

diff --git a/app/src/main/java/de/kuschku/quasseldroid/defaults/DefaultNetworkServer.kt b/app/src/main/java/de/kuschku/quasseldroid/defaults/DefaultNetworkServer.kt
index a161c49cb..df4446e95 100644
--- a/app/src/main/java/de/kuschku/quasseldroid/defaults/DefaultNetworkServer.kt
+++ b/app/src/main/java/de/kuschku/quasseldroid/defaults/DefaultNetworkServer.kt
@@ -23,6 +23,6 @@ import java.io.Serializable
 
 data class DefaultNetworkServer(
   val host: String,
-  val port: Int,
+  val port: UInt,
   val secure: Boolean
 ) : Serializable
diff --git a/app/src/main/java/de/kuschku/quasseldroid/service/BacklogRequester.kt b/app/src/main/java/de/kuschku/quasseldroid/service/BacklogRequester.kt
index 32e8771d0..1b0308f40 100644
--- a/app/src/main/java/de/kuschku/quasseldroid/service/BacklogRequester.kt
+++ b/app/src/main/java/de/kuschku/quasseldroid/service/BacklogRequester.kt
@@ -59,7 +59,7 @@ class BacklogRequester(
         ) {
           if (it.isNotEmpty()) {
             missing -= it.count {
-              (it.type.value and filtered.inv()) != 0 &&
+              (it.type.value and filtered.toUInt().inv()) != 0u &&
               !QuasselBacklogStorage.isIgnored(session, it)
             }
             val hasLoadedAll = missing == 0
diff --git a/app/src/main/java/de/kuschku/quasseldroid/ui/chat/ChatActivity.kt b/app/src/main/java/de/kuschku/quasseldroid/ui/chat/ChatActivity.kt
index 2aa901c1b..f2b0f5b30 100644
--- a/app/src/main/java/de/kuschku/quasseldroid/ui/chat/ChatActivity.kt
+++ b/app/src/main/java/de/kuschku/quasseldroid/ui/chat/ChatActivity.kt
@@ -54,6 +54,8 @@ import de.kuschku.libquassel.protocol.Message_Type
 import de.kuschku.libquassel.protocol.NetworkId
 import de.kuschku.libquassel.protocol.coresetup.CoreSetupData
 import de.kuschku.libquassel.protocol.message.HandshakeMessage
+import de.kuschku.libquassel.quassel.syncables.interfaces.INetwork.PortDefaults.PORT_PLAINTEXT
+import de.kuschku.libquassel.quassel.syncables.interfaces.INetwork.PortDefaults.PORT_SSL
 import de.kuschku.libquassel.session.Error
 import de.kuschku.libquassel.session.ISession
 import de.kuschku.libquassel.util.Optional
@@ -81,7 +83,6 @@ import de.kuschku.quasseldroid.ui.setup.network.NetworkSetupActivity
 import de.kuschku.quasseldroid.ui.setup.user.UserSetupActivity
 import de.kuschku.quasseldroid.util.backport.OsConstants
 import de.kuschku.quasseldroid.util.helper.*
-import de.kuschku.quasseldroid.util.irc.IrcPorts
 import de.kuschku.quasseldroid.util.irc.format.IrcFormatDeserializer
 import de.kuschku.quasseldroid.util.missingfeatures.MissingFeaturesDialog
 import de.kuschku.quasseldroid.util.missingfeatures.RequiredFeatures
@@ -234,9 +235,9 @@ class ChatActivity : ServiceBoundActivity(), SharedPreferences.OnSharedPreferenc
                 name = "",
                 server = DefaultNetworkServer(
                   host = uri.host ?: "",
-                  port = uri.port.nullIf { it == -1 }
-                         ?: if (uri.scheme == "irc") IrcPorts.normal
-                         else IrcPorts.secure,
+                  port = uri.port.nullIf { it < 0 }?.toUInt()
+                         ?: if (uri.scheme == "irc") PORT_PLAINTEXT.port
+                         else PORT_SSL.port,
                   secure = uri.scheme == "ircs"
                 )
               ),
@@ -833,7 +834,7 @@ class ChatActivity : ServiceBoundActivity(), SharedPreferences.OnSharedPreferenc
             accountDatabase.accounts().findById(accountId)?.defaultFiltered ?: 0
           )
           val filtered = Message_Type.of(filteredRaw)
-          val flags = intArrayOf(
+          val flags = uintArrayOf(
             Message.MessageType.Join.bit or Message.MessageType.NetsplitJoin.bit,
             Message.MessageType.Part.bit,
             Message.MessageType.Quit.bit or Message.MessageType.NetsplitQuit.bit,
@@ -849,7 +850,7 @@ class ChatActivity : ServiceBoundActivity(), SharedPreferences.OnSharedPreferenc
           MaterialDialog.Builder(this)
             .title(R.string.label_filter_messages)
             .items(R.array.message_filter_types)
-            .itemsIds(flags)
+            .itemsIds(flags.toIntArray())
             .itemsCallbackMultiChoice(selectedIndices) { _, _, _ -> false }
             .positiveText(R.string.label_select)
             .negativeText(R.string.label_use_default)
@@ -867,8 +868,8 @@ class ChatActivity : ServiceBoundActivity(), SharedPreferences.OnSharedPreferenc
                   .map { flags[it] }
                   .fold(Message_Type.of()) { acc, i -> acc or i }
 
-                accountDatabase.accounts().setFiltered(accountId, newlyFiltered.value)
-                database.filtered().setFiltered(accountId, buffer, newlyFiltered.value)
+                accountDatabase.accounts().setFiltered(accountId, newlyFiltered.value.toInt())
+                database.filtered().setFiltered(accountId, buffer, newlyFiltered.value.toInt())
               }
             }
             .onPositive { dialog, _ ->
@@ -880,7 +881,7 @@ class ChatActivity : ServiceBoundActivity(), SharedPreferences.OnSharedPreferenc
                   .fold(Message_Type.of()) { acc, i -> acc or i }
 
                 database.filtered().replace(
-                  QuasselDatabase.Filtered(accountId, buffer, newlyFiltered.value)
+                  QuasselDatabase.Filtered(accountId, buffer, newlyFiltered.value.toInt())
                 )
               }
             }
diff --git a/app/src/main/java/de/kuschku/quasseldroid/ui/chat/buffers/BufferViewConfigFragment.kt b/app/src/main/java/de/kuschku/quasseldroid/ui/chat/buffers/BufferViewConfigFragment.kt
index c064b3448..67387cf0c 100644
--- a/app/src/main/java/de/kuschku/quasseldroid/ui/chat/buffers/BufferViewConfigFragment.kt
+++ b/app/src/main/java/de/kuschku/quasseldroid/ui/chat/buffers/BufferViewConfigFragment.kt
@@ -319,15 +319,15 @@ class BufferViewConfigFragment : ServiceBoundFragment() {
           val (info, expandedNetworks, selected) = data
           val (config, list) = info ?: Pair(null, emptyList())
           val minimumActivity = config?.minimumActivity() ?: Buffer_Activity.NONE
-          val activities = activityList.associate { it.bufferId to it.filtered }
+          val activities = activityList.associate { it.bufferId to it.filtered.toUInt() }
           val processedList = list.asSequence().sortedBy { props ->
             !props.info.type.hasFlag(Buffer_Type.StatusBuffer)
           }.sortedWith(compareBy(String.CASE_INSENSITIVE_ORDER) { props ->
             props.network.networkName
           }).map { props ->
             val activity = props.activity - (activities[props.info.bufferId]
-                                             ?: account?.defaultFiltered
-                                             ?: 0)
+                                             ?: account?.defaultFiltered?.toUInt()
+                                             ?: 0u)
             BufferListItem(
               props.copy(
                 activity = activity,
diff --git a/app/src/main/java/de/kuschku/quasseldroid/ui/chat/messages/MessageAdapter.kt b/app/src/main/java/de/kuschku/quasseldroid/ui/chat/messages/MessageAdapter.kt
index 0d26a40ce..0fec43779 100644
--- a/app/src/main/java/de/kuschku/quasseldroid/ui/chat/messages/MessageAdapter.kt
+++ b/app/src/main/java/de/kuschku/quasseldroid/ui/chat/messages/MessageAdapter.kt
@@ -112,7 +112,7 @@ class MessageAdapter @Inject constructor(
   }
 
   override fun getItemViewType(position: Int) = getItem(position)?.let {
-    it.content.type.value or
+    it.content.type.value.toInt() or
       (if (it.content.flag.hasFlag(Message_Flag.Highlight)) MASK_HIGHLIGHT else 0x00) or
       (if (it.isFollowUp) MASK_FOLLOWUP else 0x00) or
       (if (it.isEmoji) MASK_EMOJI else 0x00) or
diff --git a/app/src/main/java/de/kuschku/quasseldroid/ui/coresettings/network/NetworkBaseFragment.kt b/app/src/main/java/de/kuschku/quasseldroid/ui/coresettings/network/NetworkBaseFragment.kt
index dceb01b78..402dbf473 100644
--- a/app/src/main/java/de/kuschku/quasseldroid/ui/coresettings/network/NetworkBaseFragment.kt
+++ b/app/src/main/java/de/kuschku/quasseldroid/ui/coresettings/network/NetworkBaseFragment.kt
@@ -41,6 +41,7 @@ import de.kuschku.libquassel.quassel.syncables.Network
 import de.kuschku.libquassel.quassel.syncables.interfaces.INetwork
 import de.kuschku.libquassel.session.ISession
 import de.kuschku.libquassel.util.Optional
+import de.kuschku.libquassel.util.helpers.nullIf
 import de.kuschku.quasseldroid.R
 import de.kuschku.quasseldroid.defaults.Defaults
 import de.kuschku.quasseldroid.ui.coresettings.SettingsFragment
@@ -239,7 +240,7 @@ abstract class NetworkBaseFragment(private val initDefault: Boolean) :
         customratelimitsEnabled.isChecked = data.useCustomMessageRate()
         customratelimitsBurstSize.setText(data.messageRateBurstSize().toString())
         customratelimitsUnlimited.isChecked = data.unlimitedMessageRate()
-        customratelimitsDelay.setText("${data.messageRateDelay() / 1000.0}")
+        customratelimitsDelay.setText("${data.messageRateDelay().toInt() / 1000.0}")
       }
     }
   }
@@ -296,9 +297,9 @@ abstract class NetworkBaseFragment(private val initDefault: Boolean) :
     data.setAutoIdentifyPassword(autoidentifyPassword.text.toString())
 
     data.setUseAutoReconnect(autoreconnectEnabled.isChecked)
-    data.setAutoReconnectInterval(autoreconnectInterval.text.toString().toIntOrNull()
+    data.setAutoReconnectInterval(autoreconnectInterval.text.toString().toUIntOrNull()
                                   ?: data.autoReconnectInterval())
-    data.setAutoReconnectRetries(autoreconnectRetries.text.toString().toShortOrNull()
+    data.setAutoReconnectRetries(autoreconnectRetries.text.toString().toUShortOrNull()
                                  ?: data.autoReconnectRetries())
     data.setUnlimitedReconnectRetries(autoreconnectUnlimited.isChecked)
 
@@ -306,11 +307,13 @@ abstract class NetworkBaseFragment(private val initDefault: Boolean) :
     data.setRejoinChannels(rejoinChannels.isChecked)
 
     data.setUseCustomMessageRate(customratelimitsEnabled.isChecked)
-    data.setMessageRateBurstSize(customratelimitsBurstSize.text.toString().toIntOrNull()
+    data.setMessageRateBurstSize(customratelimitsBurstSize.text.toString().toUIntOrNull()
                                  ?: data.messageRateBurstSize())
     data.setUnlimitedMessageRate(customratelimitsUnlimited.isChecked)
     data.setMessageRateDelay(customratelimitsDelay.toString().toFloatOrNull()
                                ?.let { (it * 1000).roundToInt() }
+                               ?.nullIf { it < 0 }
+                               ?.toUInt()
                              ?: data.messageRateDelay())
   }
 
diff --git a/app/src/main/java/de/kuschku/quasseldroid/ui/coresettings/networkserver/NetworkServerFragment.kt b/app/src/main/java/de/kuschku/quasseldroid/ui/coresettings/networkserver/NetworkServerFragment.kt
index 540895b74..2ad61605c 100644
--- a/app/src/main/java/de/kuschku/quasseldroid/ui/coresettings/networkserver/NetworkServerFragment.kt
+++ b/app/src/main/java/de/kuschku/quasseldroid/ui/coresettings/networkserver/NetworkServerFragment.kt
@@ -31,10 +31,11 @@ import androidx.appcompat.widget.SwitchCompat
 import butterknife.BindView
 import butterknife.ButterKnife
 import de.kuschku.libquassel.quassel.syncables.interfaces.INetwork
+import de.kuschku.libquassel.quassel.syncables.interfaces.INetwork.PortDefaults.PORT_PLAINTEXT
+import de.kuschku.libquassel.quassel.syncables.interfaces.INetwork.PortDefaults.PORT_SSL
 import de.kuschku.quasseldroid.R
 import de.kuschku.quasseldroid.ui.coresettings.SettingsFragment
 import de.kuschku.quasseldroid.util.helper.setDependent
-import de.kuschku.quasseldroid.util.irc.IrcPorts
 
 class NetworkServerFragment : SettingsFragment(), SettingsFragment.Savable,
                               SettingsFragment.Changeable {
@@ -116,10 +117,10 @@ class NetworkServerFragment : SettingsFragment(), SettingsFragment.Savable,
     sslEnabled.setOnCheckedChangeListener { _, isChecked ->
       sslVerify.isEnabled = isChecked
       val portValue = port.text.trim().toString()
-      if (isChecked && portValue == IrcPorts.normal.toString()) {
-        port.setText(IrcPorts.secure.toString())
-      } else if (!isChecked && portValue == IrcPorts.secure.toString()) {
-        port.setText(IrcPorts.normal.toString())
+      if (isChecked && portValue == PORT_PLAINTEXT.port.toString()) {
+        port.setText(PORT_SSL.port.toString())
+      } else if (!isChecked && portValue == PORT_SSL.port.toString()) {
+        port.setText(PORT_PLAINTEXT.port.toString())
       }
     }
     sslVerify.isEnabled = sslEnabled.isChecked
@@ -130,14 +131,17 @@ class NetworkServerFragment : SettingsFragment(), SettingsFragment.Savable,
   private fun applyChanges(data: INetwork.Server?): INetwork.Server {
     return INetwork.Server(
       host = host.text.toString(),
-      port = port.text.toString().toIntOrNull() ?: data?.port ?: 0,
+      port = port.text.toString().toUIntOrNull()
+             ?: data?.port
+             ?: PORT_PLAINTEXT.port,
       useSsl = sslEnabled.isChecked,
       sslVerify = sslVerify.isChecked,
       password = password.text.toString(),
       useProxy = proxyEnabled.isChecked,
       proxyType = proxyType.selectedItemId.toInt(),
       proxyHost = proxyHost.text.toString(),
-      proxyPort = proxyPort.text.toString().toIntOrNull() ?: data?.proxyPort ?: 0,
+      proxyPort = proxyPort.text.toString().toUIntOrNull()
+                  ?: data?.proxyPort ?: 0u,
       proxyUser = proxyUser.text.toString(),
       proxyPass = proxyPass.text.toString()
     )
diff --git a/app/src/main/java/de/kuschku/quasseldroid/ui/setup/network/NetworkSetupNetworkSlide.kt b/app/src/main/java/de/kuschku/quasseldroid/ui/setup/network/NetworkSetupNetworkSlide.kt
index 8a4f50b8a..24512fe83 100644
--- a/app/src/main/java/de/kuschku/quasseldroid/ui/setup/network/NetworkSetupNetworkSlide.kt
+++ b/app/src/main/java/de/kuschku/quasseldroid/ui/setup/network/NetworkSetupNetworkSlide.kt
@@ -35,6 +35,8 @@ import com.google.android.material.textfield.TextInputLayout
 import de.kuschku.libquassel.quassel.syncables.Identity
 import de.kuschku.libquassel.quassel.syncables.Network
 import de.kuschku.libquassel.quassel.syncables.interfaces.INetwork
+import de.kuschku.libquassel.quassel.syncables.interfaces.INetwork.PortDefaults.PORT_PLAINTEXT
+import de.kuschku.libquassel.quassel.syncables.interfaces.INetwork.PortDefaults.PORT_SSL
 import de.kuschku.quasseldroid.R
 import de.kuschku.quasseldroid.defaults.DefaultNetworkServer
 import de.kuschku.quasseldroid.ui.coresettings.chatlist.NetworkAdapter
@@ -44,7 +46,6 @@ import de.kuschku.quasseldroid.util.Patterns
 import de.kuschku.quasseldroid.util.TextValidator
 import de.kuschku.quasseldroid.util.helper.combineLatest
 import de.kuschku.quasseldroid.util.helper.toLiveData
-import de.kuschku.quasseldroid.util.irc.IrcPorts
 import de.kuschku.quasseldroid.util.ui.AnimationHelper
 
 class NetworkSetupNetworkSlide : ServiceBoundSlideFragment() {
@@ -115,9 +116,9 @@ class NetworkSetupNetworkSlide : ServiceBoundSlideFragment() {
           name = nameField.text.toString(),
           server = DefaultNetworkServer(
             host = hostField.text.toString(),
-            port = portField.text.toString().toIntOrNull()
-                   ?: if (sslEnabled.isChecked) 6697
-                   else 6667,
+            port = portField.text.toString().toUIntOrNull()
+                   ?: if (sslEnabled.isChecked) PORT_SSL.port
+                   else PORT_PLAINTEXT.port,
             secure = sslEnabled.isChecked
           )
         )
@@ -203,10 +204,10 @@ class NetworkSetupNetworkSlide : ServiceBoundSlideFragment() {
 
     sslEnabled.setOnCheckedChangeListener { _, isChecked ->
       val portValue = portField.text.trim().toString()
-      if (isChecked && portValue == IrcPorts.normal.toString()) {
-        portField.setText(IrcPorts.secure.toString())
-      } else if (!isChecked && portValue == IrcPorts.secure.toString()) {
-        portField.setText(IrcPorts.normal.toString())
+      if (isChecked && portValue == PORT_PLAINTEXT.port.toString()) {
+        portField.setText(PORT_SSL.port.toString())
+      } else if (!isChecked && portValue == PORT_SSL.port.toString()) {
+        portField.setText(PORT_PLAINTEXT.port.toString())
       }
     }
 
diff --git a/app/src/main/java/de/kuschku/quasseldroid/ui/setup/user/UserSetupNetworkSlide.kt b/app/src/main/java/de/kuschku/quasseldroid/ui/setup/user/UserSetupNetworkSlide.kt
index 27d71714f..8e6795c5a 100644
--- a/app/src/main/java/de/kuschku/quasseldroid/ui/setup/user/UserSetupNetworkSlide.kt
+++ b/app/src/main/java/de/kuschku/quasseldroid/ui/setup/user/UserSetupNetworkSlide.kt
@@ -31,6 +31,8 @@ import androidx.appcompat.widget.SwitchCompat
 import butterknife.BindView
 import butterknife.ButterKnife
 import com.google.android.material.textfield.TextInputLayout
+import de.kuschku.libquassel.quassel.syncables.interfaces.INetwork.PortDefaults.PORT_PLAINTEXT
+import de.kuschku.libquassel.quassel.syncables.interfaces.INetwork.PortDefaults.PORT_SSL
 import de.kuschku.libquassel.util.helpers.nullIf
 import de.kuschku.quasseldroid.R
 import de.kuschku.quasseldroid.defaults.DefaultNetwork
@@ -38,7 +40,6 @@ import de.kuschku.quasseldroid.defaults.DefaultNetworkServer
 import de.kuschku.quasseldroid.ui.setup.SlideFragment
 import de.kuschku.quasseldroid.util.Patterns
 import de.kuschku.quasseldroid.util.TextValidator
-import de.kuschku.quasseldroid.util.irc.IrcPorts
 import de.kuschku.quasseldroid.util.ui.AnimationHelper
 import javax.inject.Inject
 
@@ -110,9 +111,9 @@ class UserSetupNetworkSlide : SlideFragment() {
         servers = listOf(
           DefaultNetworkServer(
             host = hostField.text.toString(),
-            port = portField.text.toString().toIntOrNull()
-                   ?: if (sslEnabled.isChecked) 6697
-                   else 6667,
+            port = portField.text.toString().toUIntOrNull()
+                   ?: if (sslEnabled.isChecked) PORT_SSL.port
+                   else PORT_PLAINTEXT.port,
             secure = sslEnabled.isChecked
           )
         )
@@ -178,10 +179,10 @@ class UserSetupNetworkSlide : SlideFragment() {
 
     sslEnabled.setOnCheckedChangeListener { _, isChecked ->
       val portValue = portField.text.trim().toString()
-      if (isChecked && portValue == IrcPorts.normal.toString()) {
-        portField.setText(IrcPorts.secure.toString())
-      } else if (!isChecked && portValue == IrcPorts.secure.toString()) {
-        portField.setText(IrcPorts.normal.toString())
+      if (isChecked && portValue == PORT_PLAINTEXT.port.toString()) {
+        portField.setText(PORT_SSL.port.toString())
+      } else if (!isChecked && portValue == PORT_SSL.port.toString()) {
+        portField.setText(PORT_PLAINTEXT.port.toString())
       }
     }
 
diff --git a/lib/src/main/java/de/kuschku/libquassel/protocol/Message.kt b/lib/src/main/java/de/kuschku/libquassel/protocol/Message.kt
index c3d69eaac..e7f2542f7 100644
--- a/lib/src/main/java/de/kuschku/libquassel/protocol/Message.kt
+++ b/lib/src/main/java/de/kuschku/libquassel/protocol/Message.kt
@@ -36,47 +36,47 @@ data class Message(
   val avatarUrl: String,
   val content: String
 ) {
-  enum class MessageType(override val bit: Int) :
-    Flag<MessageType> {
-    Plain(0x00001),
-    Notice(0x00002),
-    Action(0x00004),
-    Nick(0x00008),
-    Mode(0x00010),
-    Join(0x00020),
-    Part(0x00040),
-    Quit(0x00080),
-    Kick(0x00100),
-    Kill(0x00200),
-    Server(0x00400),
-    Info(0x00800),
-    Error(0x01000),
-    DayChange(0x02000),
-    Topic(0x04000),
-    NetsplitJoin(0x08000),
-    NetsplitQuit(0x10000),
-    Invite(0x20000),
-    Markerline(0x40000);
+  enum class MessageType(override val bit: UInt) : Flag<MessageType> {
+    Plain(0x00001u),
+    Notice(0x00002u),
+    Action(0x00004u),
+    Nick(0x00008u),
+    Mode(0x00010u),
+    Join(0x00020u),
+    Part(0x00040u),
+    Quit(0x00080u),
+    Kick(0x00100u),
+    Kill(0x00200u),
+    Server(0x00400u),
+    Info(0x00800u),
+    Error(0x01000u),
+    DayChange(0x02000u),
+    Topic(0x04000u),
+    NetsplitJoin(0x08000u),
+    NetsplitQuit(0x10000u),
+    Invite(0x20000u),
+    Markerline(0x40000u);
 
     companion object : Flags.Factory<MessageType> {
       override val NONE = MessageType.of()
       override fun of(bit: Int) = Flags.of<MessageType>(bit)
+      override fun of(bit: UInt) = Flags.of<MessageType>(bit)
       override fun of(vararg flags: MessageType) = Flags.of(*flags)
       override fun of(flags: Iterable<MessageType>) = Flags.of(flags)
     }
   }
 
-  enum class MessageFlag(override val bit: Int) :
-    Flag<MessageFlag> {
-    Self(0x01),
-    Highlight(0x02),
-    Redirected(0x04),
-    ServerMsg(0x08),
-    Backlog(0x80);
+  enum class MessageFlag(override val bit: UInt) : Flag<MessageFlag> {
+    Self(0x01u),
+    Highlight(0x02u),
+    Redirected(0x04u),
+    ServerMsg(0x08u),
+    Backlog(0x80u);
 
     companion object : Flags.Factory<MessageFlag> {
       override val NONE = MessageFlag.of()
       override fun of(bit: Int) = Flags.of<MessageFlag>(bit)
+      override fun of(bit: UInt) = Flags.of<MessageFlag>(bit)
       override fun of(vararg flags: MessageFlag) = Flags.of(*flags)
       override fun of(flags: Iterable<MessageFlag>) = Flags.of(flags)
     }
diff --git a/lib/src/main/java/de/kuschku/libquassel/protocol/QType.kt b/lib/src/main/java/de/kuschku/libquassel/protocol/QType.kt
index 02a0cb4a7..977970a12 100644
--- a/lib/src/main/java/de/kuschku/libquassel/protocol/QType.kt
+++ b/lib/src/main/java/de/kuschku/libquassel/protocol/QType.kt
@@ -25,7 +25,8 @@ enum class QType(val typeName: String, val serializer: Serializer<*>,
                  val type: Type = Type.UserType) {
   BufferId("BufferId", IntSerializer),
   BufferInfo("BufferInfo", BufferInfoSerializer),
-  DccConfig_IpDetectionMode("DccConfig::IpDetectionMode", DccConfig_IpDetectionModeSerializer),
+  DccConfig_IpDetectionMode("DccConfig::IpDetectionMode",
+                            DccConfig_IpDetectionModeSerializer),
   DccConfig_PortSelectionMode("DccConfig::PortSelectionMode",
                               DccConfig_PortSelectionModeSerializer),
   IrcUser("IrcUser", VariantMapSerializer),
diff --git a/lib/src/main/java/de/kuschku/libquassel/protocol/QTypes.kt b/lib/src/main/java/de/kuschku/libquassel/protocol/QTypes.kt
index 25a7afc86..79ac7d4c6 100644
--- a/lib/src/main/java/de/kuschku/libquassel/protocol/QTypes.kt
+++ b/lib/src/main/java/de/kuschku/libquassel/protocol/QTypes.kt
@@ -64,11 +64,6 @@ typealias Buffer_Types = ShortFlags<Buffer_Type>
 typealias Buffer_Activity = BufferInfo.Activity
 typealias Buffer_Activities = Flags<Buffer_Activity>
 
-typealias UByte = Byte
-typealias UShort = Short
-typealias UInt = Int
-typealias ULong = Long
-
 inline fun <T> ARG(data: T?, type: Type) = QVariant.of(data, type)
 inline fun <T> ARG(data: T?, type: QType) = QVariant.of(data, type)
 
diff --git a/lib/src/main/java/de/kuschku/libquassel/protocol/Type.kt b/lib/src/main/java/de/kuschku/libquassel/protocol/Type.kt
index 5793b20fa..eedd2a53b 100644
--- a/lib/src/main/java/de/kuschku/libquassel/protocol/Type.kt
+++ b/lib/src/main/java/de/kuschku/libquassel/protocol/Type.kt
@@ -26,7 +26,7 @@ enum class Type(val id: kotlin.Int, val serializer: Serializer<*>? = null) {
   Void(0, VoidSerializer),
   Bool(1, BoolSerializer),
   Int(2, IntSerializer),
-  UInt(3, IntSerializer),
+  UInt(3, UIntSerializer),
   LongLong(4),
   ULongLong(5),
 
@@ -95,10 +95,10 @@ enum class Type(val id: kotlin.Int, val serializer: Serializer<*>? = null) {
   Long(129, LongSerializer),
   Short(130, ShortSerializer),
   Char(131, ByteSerializer),
-  ULong(132, LongSerializer),
+  ULong(132, ULongSerializer),
 
-  UShort(133, ShortSerializer),
-  UChar(134, ByteSerializer),
+  UShort(133, UShortSerializer),
+  UChar(134, UByteSerializer),
   Float(135),
   QObjectStar(136),
   QWidgetStar(137),
diff --git a/lib/src/main/java/de/kuschku/libquassel/protocol/message/ClientInitAckSerializer.kt b/lib/src/main/java/de/kuschku/libquassel/protocol/message/ClientInitAckSerializer.kt
index f51ccc0f1..490a5bd50 100644
--- a/lib/src/main/java/de/kuschku/libquassel/protocol/message/ClientInitAckSerializer.kt
+++ b/lib/src/main/java/de/kuschku/libquassel/protocol/message/ClientInitAckSerializer.kt
@@ -25,7 +25,7 @@ import de.kuschku.libquassel.util.flag.Flags
 object ClientInitAckSerializer : HandshakeMessageSerializer<HandshakeMessage.ClientInitAck> {
   override fun serialize(data: HandshakeMessage.ClientInitAck) = mapOf(
     "MsgType" to QVariant.of<All_>("ClientInitAck", Type.QString),
-    "CoreFeatures" to QVariant.of<All_>(data.coreFeatures?.toInt(), Type.UInt),
+    "CoreFeatures" to QVariant.of<All_>(data.coreFeatures?.toUInt(), Type.UInt),
     "StorageBackends" to QVariant.of<All_>(data.backendInfo, Type.QVariantList),
     "Authenticator" to QVariant.of<All_>(data.authenticatorInfo, Type.QVariantList),
     "Configured" to QVariant.of<All_>(data.coreConfigured, Type.Bool),
@@ -33,7 +33,7 @@ object ClientInitAckSerializer : HandshakeMessageSerializer<HandshakeMessage.Cli
   )
 
   override fun deserialize(data: QVariantMap) = HandshakeMessage.ClientInitAck(
-    coreFeatures = Flags.of(data["CoreFeatures"].value(0)),
+    coreFeatures = Flags.of(data["CoreFeatures"].value(0u)),
     backendInfo = data["StorageBackends"].value(),
     authenticatorInfo = data["Authenticators"].value(),
     coreConfigured = data["Configured"].value(),
diff --git a/lib/src/main/java/de/kuschku/libquassel/protocol/message/ClientInitSerializer.kt b/lib/src/main/java/de/kuschku/libquassel/protocol/message/ClientInitSerializer.kt
index a5274eda1..d3dd4a819 100644
--- a/lib/src/main/java/de/kuschku/libquassel/protocol/message/ClientInitSerializer.kt
+++ b/lib/src/main/java/de/kuschku/libquassel/protocol/message/ClientInitSerializer.kt
@@ -30,14 +30,14 @@ object ClientInitSerializer : HandshakeMessageSerializer<HandshakeMessage.Client
     "MsgType" to QVariant.of("ClientInit", Type.QString),
     "ClientVersion" to QVariant.of(data.clientVersion, Type.QString),
     "ClientDate" to QVariant.of(data.buildDate, Type.QString),
-    "Features" to QVariant.of(data.clientFeatures?.toInt(), Type.UInt),
+    "Features" to QVariant.of(data.clientFeatures?.toUInt(), Type.UInt),
     "FeatureList" to QVariant.of(data.featureList, Type.QStringList)
   )
 
   override fun deserialize(data: QVariantMap) = HandshakeMessage.ClientInit(
     clientVersion = data["ClientVersion"].value(),
     buildDate = data["ClientDate"].value(),
-    clientFeatures = Flags.of(data["Features"].value(0)),
+    clientFeatures = Flags.of(data["Features"].value(0u)),
     featureList = data["FeatureList"].value(emptyList())
   )
 }
diff --git a/lib/src/main/java/de/kuschku/libquassel/protocol/primitive/serializer/DccConfig_IpDetectionModeSerializer.kt b/lib/src/main/java/de/kuschku/libquassel/protocol/primitive/serializer/DccConfig_IpDetectionModeSerializer.kt
index a8432beab..d18a94e10 100644
--- a/lib/src/main/java/de/kuschku/libquassel/protocol/primitive/serializer/DccConfig_IpDetectionModeSerializer.kt
+++ b/lib/src/main/java/de/kuschku/libquassel/protocol/primitive/serializer/DccConfig_IpDetectionModeSerializer.kt
@@ -27,11 +27,11 @@ import java.nio.ByteBuffer
 object DccConfig_IpDetectionModeSerializer : Serializer<IDccConfig.IpDetectionMode> {
   override fun serialize(buffer: ChainedByteBuffer, data: IDccConfig.IpDetectionMode,
                          features: QuasselFeatures) {
-    buffer.put(data.value)
+    UByteSerializer.serialize(buffer, data.value, features)
   }
 
   override fun deserialize(buffer: ByteBuffer,
                            features: QuasselFeatures): IDccConfig.IpDetectionMode {
-    return IDccConfig.IpDetectionMode.of(buffer.get())
+    return IDccConfig.IpDetectionMode.of(UByteSerializer.deserialize(buffer, features))
   }
 }
diff --git a/lib/src/main/java/de/kuschku/libquassel/protocol/primitive/serializer/DccConfig_PortSelectionModeSerializer.kt b/lib/src/main/java/de/kuschku/libquassel/protocol/primitive/serializer/DccConfig_PortSelectionModeSerializer.kt
index b9f267932..47792fdf6 100644
--- a/lib/src/main/java/de/kuschku/libquassel/protocol/primitive/serializer/DccConfig_PortSelectionModeSerializer.kt
+++ b/lib/src/main/java/de/kuschku/libquassel/protocol/primitive/serializer/DccConfig_PortSelectionModeSerializer.kt
@@ -27,11 +27,11 @@ import java.nio.ByteBuffer
 object DccConfig_PortSelectionModeSerializer : Serializer<IDccConfig.PortSelectionMode> {
   override fun serialize(buffer: ChainedByteBuffer, data: IDccConfig.PortSelectionMode,
                          features: QuasselFeatures) {
-    buffer.put(data.value)
+    UByteSerializer.serialize(buffer, data.value, features)
   }
 
   override fun deserialize(buffer: ByteBuffer,
                            features: QuasselFeatures): IDccConfig.PortSelectionMode {
-    return IDccConfig.PortSelectionMode.of(buffer.get())
+    return IDccConfig.PortSelectionMode.of(UByteSerializer.deserialize(buffer, features))
   }
 }
diff --git a/lib/src/main/java/de/kuschku/libquassel/protocol/primitive/serializer/ProtocolInfoSerializer.kt b/lib/src/main/java/de/kuschku/libquassel/protocol/primitive/serializer/ProtocolInfoSerializer.kt
index 2b84064d9..9cba27814 100644
--- a/lib/src/main/java/de/kuschku/libquassel/protocol/primitive/serializer/ProtocolInfoSerializer.kt
+++ b/lib/src/main/java/de/kuschku/libquassel/protocol/primitive/serializer/ProtocolInfoSerializer.kt
@@ -28,14 +28,14 @@ import java.nio.ByteBuffer
 object ProtocolInfoSerializer : Serializer<ProtocolInfo> {
   override fun serialize(buffer: ChainedByteBuffer, data: ProtocolInfo,
                          features: QuasselFeatures) {
-    ByteSerializer.serialize(buffer, data.flags.toByte(), features)
+    UByteSerializer.serialize(buffer, data.flags.toUByte(), features)
     ShortSerializer.serialize(buffer, data.data, features)
     ByteSerializer.serialize(buffer, data.version, features)
   }
 
   override fun deserialize(buffer: ByteBuffer, features: QuasselFeatures): ProtocolInfo {
     return ProtocolInfo(
-      Protocol_Features.of(ByteSerializer.deserialize(buffer, features).toInt()),
+      Protocol_Features.of(UByteSerializer.deserialize(buffer, features).toUInt()),
       ShortSerializer.deserialize(buffer, features),
       ByteSerializer.deserialize(buffer, features)
     )
diff --git a/lib/src/main/java/de/kuschku/libquassel/protocol/primitive/serializer/UByteSerializer.kt b/lib/src/main/java/de/kuschku/libquassel/protocol/primitive/serializer/UByteSerializer.kt
new file mode 100644
index 000000000..06fea4a85
--- /dev/null
+++ b/lib/src/main/java/de/kuschku/libquassel/protocol/primitive/serializer/UByteSerializer.kt
@@ -0,0 +1,34 @@
+/*
+ * Quasseldroid - Quassel client for Android
+ *
+ * Copyright (c) 2019 Janne Koschinski
+ * Copyright (c) 2019 The Quassel Project
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3 as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package de.kuschku.libquassel.protocol.primitive.serializer
+
+import de.kuschku.libquassel.quassel.QuasselFeatures
+import de.kuschku.libquassel.util.nio.ChainedByteBuffer
+import java.nio.ByteBuffer
+
+object UByteSerializer : Serializer<UByte> {
+  override fun serialize(buffer: ChainedByteBuffer, data: UByte, features: QuasselFeatures) {
+    buffer.put(data.toByte())
+  }
+
+  override fun deserialize(buffer: ByteBuffer, features: QuasselFeatures): UByte {
+    return buffer.get().toUByte()
+  }
+}
diff --git a/app/src/main/java/de/kuschku/quasseldroid/util/irc/IrcPorts.kt b/lib/src/main/java/de/kuschku/libquassel/protocol/primitive/serializer/UIntSerializer.kt
similarity index 59%
rename from app/src/main/java/de/kuschku/quasseldroid/util/irc/IrcPorts.kt
rename to lib/src/main/java/de/kuschku/libquassel/protocol/primitive/serializer/UIntSerializer.kt
index b2ac159e9..36cca7f7b 100644
--- a/app/src/main/java/de/kuschku/quasseldroid/util/irc/IrcPorts.kt
+++ b/lib/src/main/java/de/kuschku/libquassel/protocol/primitive/serializer/UIntSerializer.kt
@@ -17,9 +17,18 @@
  * with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-package de.kuschku.quasseldroid.util.irc
+package de.kuschku.libquassel.protocol.primitive.serializer
 
-object IrcPorts {
-  const val normal = 6667
-  const val secure = 6697
+import de.kuschku.libquassel.quassel.QuasselFeatures
+import de.kuschku.libquassel.util.nio.ChainedByteBuffer
+import java.nio.ByteBuffer
+
+object UIntSerializer : Serializer<UInt> {
+  override fun serialize(buffer: ChainedByteBuffer, data: UInt, features: QuasselFeatures) {
+    buffer.putInt(data.toInt())
+  }
+
+  override fun deserialize(buffer: ByteBuffer, features: QuasselFeatures): UInt {
+    return buffer.int.toUInt()
+  }
 }
diff --git a/lib/src/main/java/de/kuschku/libquassel/protocol/primitive/serializer/ULongSerializer.kt b/lib/src/main/java/de/kuschku/libquassel/protocol/primitive/serializer/ULongSerializer.kt
new file mode 100644
index 000000000..e6c47b5f1
--- /dev/null
+++ b/lib/src/main/java/de/kuschku/libquassel/protocol/primitive/serializer/ULongSerializer.kt
@@ -0,0 +1,34 @@
+/*
+ * Quasseldroid - Quassel client for Android
+ *
+ * Copyright (c) 2019 Janne Koschinski
+ * Copyright (c) 2019 The Quassel Project
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3 as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package de.kuschku.libquassel.protocol.primitive.serializer
+
+import de.kuschku.libquassel.quassel.QuasselFeatures
+import de.kuschku.libquassel.util.nio.ChainedByteBuffer
+import java.nio.ByteBuffer
+
+object ULongSerializer : Serializer<ULong> {
+  override fun serialize(buffer: ChainedByteBuffer, data: ULong, features: QuasselFeatures) {
+    buffer.putLong(data.toLong())
+  }
+
+  override fun deserialize(buffer: ByteBuffer, features: QuasselFeatures): ULong {
+    return buffer.long.toULong()
+  }
+}
diff --git a/lib/src/main/java/de/kuschku/libquassel/protocol/primitive/serializer/UShortSerializer.kt b/lib/src/main/java/de/kuschku/libquassel/protocol/primitive/serializer/UShortSerializer.kt
new file mode 100644
index 000000000..e95738fae
--- /dev/null
+++ b/lib/src/main/java/de/kuschku/libquassel/protocol/primitive/serializer/UShortSerializer.kt
@@ -0,0 +1,34 @@
+/*
+ * Quasseldroid - Quassel client for Android
+ *
+ * Copyright (c) 2019 Janne Koschinski
+ * Copyright (c) 2019 The Quassel Project
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3 as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package de.kuschku.libquassel.protocol.primitive.serializer
+
+import de.kuschku.libquassel.quassel.QuasselFeatures
+import de.kuschku.libquassel.util.nio.ChainedByteBuffer
+import java.nio.ByteBuffer
+
+object UShortSerializer : Serializer<UShort> {
+  override fun serialize(buffer: ChainedByteBuffer, data: UShort, features: QuasselFeatures) {
+    buffer.putShort(data.toShort())
+  }
+
+  override fun deserialize(buffer: ByteBuffer, features: QuasselFeatures): UShort {
+    return buffer.short.toUShort()
+  }
+}
diff --git a/lib/src/main/java/de/kuschku/libquassel/quassel/BufferInfo.kt b/lib/src/main/java/de/kuschku/libquassel/quassel/BufferInfo.kt
index 89efe81ce..3e7510584 100644
--- a/lib/src/main/java/de/kuschku/libquassel/quassel/BufferInfo.kt
+++ b/lib/src/main/java/de/kuschku/libquassel/quassel/BufferInfo.kt
@@ -33,30 +33,33 @@ data class BufferInfo(
   var groupId: Int = -1,
   var bufferName: String? = null
 ) {
-  enum class Type(override val bit: Short) : ShortFlag<Type> {
-    InvalidBuffer(0x00),
-    StatusBuffer(0x01),
-    ChannelBuffer(0x02),
-    QueryBuffer(0x04),
-    GroupBuffer(0x08);
+  enum class Type(override val bit: UShort) : ShortFlag<Type> {
+    InvalidBuffer(0x00u),
+    StatusBuffer(0x01u),
+    ChannelBuffer(0x02u),
+    QueryBuffer(0x04u),
+    GroupBuffer(0x08u);
 
     companion object : ShortFlags.Factory<Type> {
-      val validValues = values().filter { it.bit != 0.toShort() }.toTypedArray()
+      override val NONE = Buffer_Type.of()
+      val validValues = values().filter { it.bit != 0u.toUShort() }.toTypedArray()
       override fun of(bit: Short) = ShortFlags.of<Type>(bit)
+      override fun of(bit: UShort) = ShortFlags.of<Type>(bit)
       override fun of(vararg flags: Type) = ShortFlags.of(*flags)
       override fun of(flags: Iterable<Type>) = ShortFlags.of(flags)
     }
   }
 
-  enum class Activity(override val bit: Int) : Flag<Activity> {
-    NoActivity(0x00),
-    OtherActivity(0x01),
-    NewMessage(0x02),
-    Highlight(0x04);
+  enum class Activity(override val bit: UInt) : Flag<Activity> {
+    NoActivity(0x00u),
+    OtherActivity(0x01u),
+    NewMessage(0x02u),
+    Highlight(0x04u);
 
     companion object : Flags.Factory<Activity> {
       override val NONE = Activity.of()
       override fun of(bit: Int) = Flags.of<Activity>(bit)
+      override fun of(bit: UInt) = Flags.of<Activity>(bit)
       override fun of(vararg flags: Activity) = Flags.of(*flags)
       override fun of(flags: Iterable<Activity>) = Flags.of(flags)
     }
diff --git a/lib/src/main/java/de/kuschku/libquassel/quassel/LegacyFeature.kt b/lib/src/main/java/de/kuschku/libquassel/quassel/LegacyFeature.kt
index c429bb6cf..828198e84 100644
--- a/lib/src/main/java/de/kuschku/libquassel/quassel/LegacyFeature.kt
+++ b/lib/src/main/java/de/kuschku/libquassel/quassel/LegacyFeature.kt
@@ -31,37 +31,38 @@ import de.kuschku.libquassel.util.flag.Flags
  *
  * This list should be cleaned up after every protocol break, as we can assume them to be present then.
  */
-enum class LegacyFeature(override val bit: Int) : Flag<LegacyFeature> {
-  SynchronizedMarkerLine(0x0001),
-  SaslAuthentication(0x0002),
-  SaslExternal(0x0004),
-  HideInactiveNetworks(0x0008),
-  PasswordChange(0x0010),
+enum class LegacyFeature(override val bit: UInt) : Flag<LegacyFeature> {
+  SynchronizedMarkerLine(0x0001u),
+  SaslAuthentication(0x0002u),
+  SaslExternal(0x0004u),
+  HideInactiveNetworks(0x0008u),
+  PasswordChange(0x0010u),
   /** IRCv3 capability negotiation, account tracking */
-  CapNegotiation(0x0020),
+  CapNegotiation(0x0020u),
   /** IRC server SSL validation */
-  VerifyServerSSL(0x0040),
+  VerifyServerSSL(0x0040u),
   /** IRC server custom message rate limits */
-  CustomRateLimits(0x0080),
-  DccFileTransfer(0x0100),
+  CustomRateLimits(0x0080u),
+  DccFileTransfer(0x0100u),
   /** Timestamp formatting in away (e.g. %%hh:mm%%) */
-  AwayFormatTimestamp(0x0200),
+  AwayFormatTimestamp(0x0200u),
   /** Whether or not the core supports auth backends. */
-  Authenticators(0x0400),
+  Authenticators(0x0400u),
   /** Sync buffer activity status */
-  BufferActivitySync(0x0800),
+  BufferActivitySync(0x0800u),
   /** Core-Side highlight configuration and matching */
-  CoreSideHighlights(0x1000),
+  CoreSideHighlights(0x1000u),
   /** Show prefixes for senders in backlog */
-  SenderPrefixes(0x2000),
+  SenderPrefixes(0x2000u),
   /** Supports RPC call disconnectFromCore to remotely disconnect a client */
-  RemoteDisconnect(0x4000),
+  RemoteDisconnect(0x4000u),
   /** Transmit features as list of strings */
-  ExtendedFeatures(0x8000);
+  ExtendedFeatures(0x8000u);
 
   companion object : Flags.Factory<LegacyFeature> {
     override val NONE: Flags<LegacyFeature> = LegacyFeature.of()
     override fun of(bit: Int) = Flags.of<LegacyFeature>(bit)
+    override fun of(bit: UInt) = Flags.of<LegacyFeature>(bit)
     override fun of(vararg flags: LegacyFeature) = Flags.of(*flags)
     override fun of(flags: Iterable<LegacyFeature>) = Flags.of(flags)
 
diff --git a/lib/src/main/java/de/kuschku/libquassel/quassel/ProtocolFeature.kt b/lib/src/main/java/de/kuschku/libquassel/quassel/ProtocolFeature.kt
index e61c88fcf..af22b81f6 100644
--- a/lib/src/main/java/de/kuschku/libquassel/quassel/ProtocolFeature.kt
+++ b/lib/src/main/java/de/kuschku/libquassel/quassel/ProtocolFeature.kt
@@ -22,15 +22,16 @@ package de.kuschku.libquassel.quassel
 import de.kuschku.libquassel.util.flag.Flag
 import de.kuschku.libquassel.util.flag.Flags
 
-enum class ProtocolFeature(override val bit: Int) :
+enum class ProtocolFeature(override val bit: UInt) :
   Flag<ProtocolFeature> {
-  None(0x00),
-  TLS(0x01),
-  Compression(0x02);
+  None(0x00u),
+  TLS(0x01u),
+  Compression(0x02u);
 
   companion object : Flags.Factory<ProtocolFeature> {
     override val NONE = ProtocolFeature.of()
     override fun of(bit: Int) = Flags.of<ProtocolFeature>(bit)
+    override fun of(bit: UInt) = Flags.of<ProtocolFeature>(bit)
     override fun of(vararg flags: ProtocolFeature) = Flags.of(*flags)
     override fun of(flags: Iterable<ProtocolFeature>) = Flags.of(flags)
   }
diff --git a/lib/src/main/java/de/kuschku/libquassel/quassel/syncables/BufferViewConfig.kt b/lib/src/main/java/de/kuschku/libquassel/quassel/syncables/BufferViewConfig.kt
index 6dbda7b42..361b64b91 100644
--- a/lib/src/main/java/de/kuschku/libquassel/quassel/syncables/BufferViewConfig.kt
+++ b/lib/src/main/java/de/kuschku/libquassel/quassel/syncables/BufferViewConfig.kt
@@ -99,7 +99,7 @@ class BufferViewConfig constructor(
     _hideInactiveNetworks = properties["hideInactiveNetworks"].valueOr(this::hideInactiveNetworks)
     _disableDecoration = properties["disableDecoration"].valueOr(this::disableDecoration)
     _allowedBufferTypes = Buffer_Type.of(properties["allowedBufferTypes"].value(_allowedBufferTypes.value.toInt()).toShort())
-    _minimumActivity = Buffer_Activity.of(properties["minimumActivity"].value(_minimumActivity.value))
+    _minimumActivity = Buffer_Activity.of(properties["minimumActivity"].value(_minimumActivity.value.toInt()))
     _showSearch = properties["showSearch"].valueOr(this::showSearch)
   }
 
@@ -302,7 +302,7 @@ class BufferViewConfig constructor(
       field = value
       live_config.onNext(Unit)
     }
-  private var _minimumActivity: Buffer_Activities = Buffer_Activities.of(0)
+  private var _minimumActivity: Buffer_Activities = Buffer_Activities.of(0u)
     set(value) {
       field = value
       live_config.onNext(Unit)
diff --git a/lib/src/main/java/de/kuschku/libquassel/quassel/syncables/DccConfig.kt b/lib/src/main/java/de/kuschku/libquassel/quassel/syncables/DccConfig.kt
index db0e69672..6cf76410a 100644
--- a/lib/src/main/java/de/kuschku/libquassel/quassel/syncables/DccConfig.kt
+++ b/lib/src/main/java/de/kuschku/libquassel/quassel/syncables/DccConfig.kt
@@ -148,10 +148,10 @@ class DccConfig constructor(
   private var _portSelectionMode: IDccConfig.PortSelectionMode = IDccConfig.PortSelectionMode.Automatic
 
   /**  Minimum port to use for incoming connections */
-  private var _minPort: UShort = 1024
+  private var _minPort: UShort = 1024u
 
   /**  Maximum port to use for incoming connections */
-  private var _maxPort: UShort = 32767
+  private var _maxPort: UShort = 32767u
 
   /**  The chunk size to be used */
   private var _chunkSize: Int = 16
diff --git a/lib/src/main/java/de/kuschku/libquassel/quassel/syncables/Network.kt b/lib/src/main/java/de/kuschku/libquassel/quassel/syncables/Network.kt
index 877a4acf4..18f46d182 100644
--- a/lib/src/main/java/de/kuschku/libquassel/quassel/syncables/Network.kt
+++ b/lib/src/main/java/de/kuschku/libquassel/quassel/syncables/Network.kt
@@ -373,7 +373,7 @@ class Network constructor(
   }.distinctUntilChanged()
 
   fun ircUsers() = _ircUsers.values.toList()
-  fun ircUserCount(): UInt = _ircUsers.size
+  fun ircUserCount(): UInt = _ircUsers.size.toUInt()
   fun newIrcChannel(channelName: String, initData: QVariantMap = emptyMap(),
                     index: Int? = null): IrcChannel =
     ircChannel(channelName).let { channel ->
@@ -401,7 +401,7 @@ class Network constructor(
   }.distinctUntilChanged()
 
   fun ircChannels() = _ircChannels.values.toList()
-  fun ircChannelCount(): UInt = _ircChannels.size
+  fun ircChannelCount(): UInt = _ircChannels.size.toUInt()
   fun codecForServer(): String = _codecForServer
   fun codecForEncoding(): String = _codecForEncoding
   fun codecForDecoding(): String = _codecForDecoding
@@ -581,7 +581,7 @@ class Network constructor(
   override fun setMessageRateBurstSize(burstSize: UInt) {
     if (_messageRateBurstSize == burstSize)
       return
-    if (burstSize < 1)
+    if (burstSize == 0u)
       throw IllegalArgumentException("Message Burst Size must be a positive number: $burstSize")
     _messageRateBurstSize = burstSize
   }
@@ -589,7 +589,7 @@ class Network constructor(
   override fun setMessageRateDelay(messageDelay: UInt) {
     if (_messageRateDelay == messageDelay)
       return
-    if (messageDelay < 1)
+    if (messageDelay == 0u)
       throw IllegalArgumentException("Message Delay must be a positive number: $messageDelay")
     _messageRateDelay = messageDelay
   }
@@ -944,12 +944,12 @@ class Network constructor(
       field = value
       live_networkInfo.onNext(Unit)
     }
-  private var _autoReconnectInterval: UInt = 60
+  private var _autoReconnectInterval: UInt = 60u
     set(value) {
       field = value
       live_networkInfo.onNext(Unit)
     }
-  private var _autoReconnectRetries: UShort = 10
+  private var _autoReconnectRetries: UShort = 10u
     set(value) {
       field = value
       live_networkInfo.onNext(Unit)
@@ -972,13 +972,13 @@ class Network constructor(
       live_networkInfo.onNext(Unit)
     }
   /** Maximum number of messages to send without any delays */
-  private var _messageRateBurstSize: UInt = 5
+  private var _messageRateBurstSize: UInt = 5u
     set(value) {
       field = value
       live_networkInfo.onNext(Unit)
     }
   /** Delay in ms. for messages when max. burst messages sent */
-  private var _messageRateDelay: UInt = 2200
+  private var _messageRateDelay: UInt = 2200u
     set(value) {
       field = value
       live_networkInfo.onNext(Unit)
diff --git a/lib/src/main/java/de/kuschku/libquassel/quassel/syncables/interfaces/IDccConfig.kt b/lib/src/main/java/de/kuschku/libquassel/quassel/syncables/interfaces/IDccConfig.kt
index ba79847e4..328713daa 100644
--- a/lib/src/main/java/de/kuschku/libquassel/quassel/syncables/interfaces/IDccConfig.kt
+++ b/lib/src/main/java/de/kuschku/libquassel/quassel/syncables/interfaces/IDccConfig.kt
@@ -21,7 +21,10 @@ package de.kuschku.libquassel.quassel.syncables.interfaces
 
 import de.kuschku.libquassel.annotations.Slot
 import de.kuschku.libquassel.annotations.Syncable
-import de.kuschku.libquassel.protocol.*
+import de.kuschku.libquassel.protocol.ARG
+import de.kuschku.libquassel.protocol.QType
+import de.kuschku.libquassel.protocol.QVariantMap
+import de.kuschku.libquassel.protocol.Type
 import java.net.InetAddress
 
 @Syncable(name = "DccConfig")
@@ -90,9 +93,9 @@ interface IDccConfig : ISyncableObject {
    */
   enum class IpDetectionMode(val value: UByte) {
     /** Automatic detection (network socket or USERHOST) */
-    Automatic(0x00),
+    Automatic(0x00u),
     /** Manually specified IP */
-    Manual(0x01);
+    Manual(0x01u);
 
     companion object {
       private val byId = IpDetectionMode.values().associateBy(IpDetectionMode::value)
@@ -105,9 +108,9 @@ interface IDccConfig : ISyncableObject {
    */
   enum class PortSelectionMode(val value: UByte) {
     /** Automatic port selection */
-    Automatic(0x00),
+    Automatic(0x00u),
     /** Manually specified port range */
-    Manual(0x01);
+    Manual(0x01u);
 
     companion object {
       private val byId = PortSelectionMode.values().associateBy(PortSelectionMode::value)
diff --git a/lib/src/main/java/de/kuschku/libquassel/quassel/syncables/interfaces/INetwork.kt b/lib/src/main/java/de/kuschku/libquassel/quassel/syncables/interfaces/INetwork.kt
index f21a11950..59cb8f271 100644
--- a/lib/src/main/java/de/kuschku/libquassel/quassel/syncables/interfaces/INetwork.kt
+++ b/lib/src/main/java/de/kuschku/libquassel/quassel/syncables/interfaces/INetwork.kt
@@ -203,18 +203,19 @@ interface INetwork : ISyncableObject {
    * {@see http://www.irc.org/tech_docs/005.html}
    * {@see http://www.irc.org/tech_docs/draft-brocklesby-irc-isupport-03.txt}
    */
-  enum class ChannelModeType(override val bit: Int) :
+  enum class ChannelModeType(override val bit: UInt) :
     Flag<ChannelModeType> {
-    NOT_A_CHANMODE(0x00),
-    A_CHANMODE(0x01),
-    B_CHANMODE(0x02),
-    C_CHANMODE(0x04),
-    D_CHANMODE(0x08);
+    NOT_A_CHANMODE(0x00u),
+    A_CHANMODE(0x01u),
+    B_CHANMODE(0x02u),
+    C_CHANMODE(0x04u),
+    D_CHANMODE(0x08u);
 
     companion object : Flags.Factory<ChannelModeType> {
       override val NONE = ChannelModeType.of()
-      val validValues = values().filter { it.bit != 0 }.toTypedArray()
+      val validValues = values().filter { it.bit != 0u }.toTypedArray()
       override fun of(bit: Int) = Flags.of<ChannelModeType>(bit)
+      override fun of(bit: UInt) = Flags.of<ChannelModeType>(bit)
       override fun of(vararg flags: ChannelModeType) = Flags.of(*flags)
       override fun of(flags: Iterable<ChannelModeType>) = Flags.of(flags)
     }
@@ -227,9 +228,9 @@ interface INetwork : ISyncableObject {
    */
   enum class PortDefaults(val port: UInt) {
     /** Default port for unencrypted connections */
-    PORT_PLAINTEXT(6667),
+    PORT_PLAINTEXT(6667u),
     /** Default port for encrypted connections */
-    PORT_SSL(6697)
+    PORT_SSL(6697u)
   }
 
   data class Server(
@@ -242,7 +243,7 @@ interface INetwork : ISyncableObject {
     val useProxy: Boolean = false,
     val proxyType: Int = ProxyType.Socks5Proxy.value,
     val proxyHost: String = "localhost",
-    val proxyPort: UInt = 8080,
+    val proxyPort: UInt = 8080u,
     val proxyUser: String = "",
     val proxyPass: String = ""
   ) : Serializable {
@@ -272,7 +273,7 @@ interface INetwork : ISyncableObject {
         useProxy = map["UseProxy"].value(false),
         proxyType = map["ProxyType"].value(ProxyType.Socks5Proxy.value),
         proxyHost = map["ProxyHost"].value("localhost"),
-        proxyPort = map["ProxyPort"].value(8080),
+        proxyPort = map["ProxyPort"].value(8080u),
         proxyUser = map["ProxyUser"].value(""),
         proxyPass = map["ProxyPass"].value("")
       )
@@ -312,13 +313,13 @@ interface INetwork : ISyncableObject {
     var saslAccount: String? = null,
     var saslPassword: String? = null,
     var useAutoReconnect: Boolean = true,
-    var autoReconnectInterval: Int = 0,
-    var autoReconnectRetries: Short = 0,
+    var autoReconnectInterval: UInt = 0u,
+    var autoReconnectRetries: UShort = 0u,
     var unlimitedReconnectRetries: Boolean = true,
     var rejoinChannels: Boolean = true,
     var useCustomMessageRate: Boolean = false,
-    var messageRateBurstSize: Int = 0,
-    var messageRateDelay: Int = 0,
+    var messageRateBurstSize: UInt = 0u,
+    var messageRateDelay: UInt = 0u,
     var unlimitedMessageRate: Boolean = false
   ) {
     fun toVariantMap() = mapOf(
@@ -348,7 +349,7 @@ interface INetwork : ISyncableObject {
       "SaslPassword" to QVariant.of(saslPassword, Type.QString),
       "UseAutoReconnect" to QVariant.of(useAutoReconnect, Type.Bool),
       "AutoReconnectInterval" to QVariant.of(autoReconnectInterval, Type.UInt),
-      "AutoReconnectRetries" to QVariant.of(autoReconnectRetries, Type.Int),
+      "AutoReconnectRetries" to QVariant.of(autoReconnectRetries, Type.UShort),
       "UnlimitedReconnectRetries" to QVariant.of(unlimitedReconnectRetries, Type.Bool),
       "RejoinChannels" to QVariant.of(rejoinChannels, Type.Bool),
       "UseCustomMessageRate" to QVariant.of(useCustomMessageRate, Type.Bool),
diff --git a/lib/src/main/java/de/kuschku/libquassel/util/flag/Flag.kt b/lib/src/main/java/de/kuschku/libquassel/util/flag/Flag.kt
index 2c4655efd..a73c80f57 100644
--- a/lib/src/main/java/de/kuschku/libquassel/util/flag/Flag.kt
+++ b/lib/src/main/java/de/kuschku/libquassel/util/flag/Flag.kt
@@ -19,29 +19,40 @@
 
 package de.kuschku.libquassel.util.flag
 
+import de.kuschku.libquassel.util.helpers.sum
+
 interface Flag<T> where T : Enum<T>, T : Flag<T> {
-  val bit: Int
+  val bit: UInt
   fun toByte() = bit.toByte()
-  fun toChar() = bit.toChar()
-  fun toDouble() = bit.toDouble()
-  fun toFloat() = bit.toFloat()
-  fun toInt() = bit
+  fun toChar() = bit.toLong().toChar()
+  fun toDouble() = bit.toLong().toDouble()
+  fun toFloat() = bit.toLong().toFloat()
+  fun toInt() = bit.toInt()
   fun toLong() = bit.toLong()
   fun toShort() = bit.toShort()
+  fun toUByte() = bit.toUByte()
+  fun toUInt() = bit.toUInt()
+  fun toULong() = bit.toULong()
+  fun toUShort() = bit.toUShort()
 }
 
 data class Flags<E>(
-  val value: Int,
+  val value: UInt,
   val values: Array<E>? = null
-) : Number(), Comparable<Int> where E : Enum<E>, E : Flag<E> {
-  override fun compareTo(other: Int) = value.compareTo(other)
+) : Number(), Comparable<UInt> where E : Enum<E>, E : Flag<E> {
+  override fun compareTo(other: UInt) = value.compareTo(other)
+
   override fun toByte() = value.toByte()
-  override fun toChar() = value.toChar()
-  override fun toDouble() = value.toDouble()
-  override fun toFloat() = value.toFloat()
-  override fun toInt() = value
+  override fun toChar() = value.toLong().toChar()
+  override fun toDouble() = value.toLong().toDouble()
+  override fun toFloat() = value.toLong().toFloat()
+  override fun toInt() = value.toInt()
   override fun toLong() = value.toLong()
   override fun toShort() = value.toShort()
+  fun toUByte() = value.toUByte()
+  fun toUInt() = value.toUInt()
+  fun toULong() = value.toULong()
+  fun toUShort() = value.toUShort()
 
   override fun equals(other: Any?) = when (other) {
     is Flags<*> -> other.value == value
@@ -50,12 +61,12 @@ data class Flags<E>(
   }
 
   override fun hashCode(): Int {
-    return value
+    return value.hashCode()
   }
 
   fun enabledValues() = values?.filter { hasFlag(it) }?.toSet() ?: emptySet()
 
-  fun isEmpty() = value == 0
+  fun isEmpty() = value == 0u
   fun isNotEmpty() = !isEmpty()
 
   override fun toString() = if (values != null) {
@@ -66,6 +77,10 @@ data class Flags<E>(
 
   companion object {
     inline fun <reified T> of(int: Int): Flags<T>
+      where T : Flag<T>, T : Enum<T> =
+      Flags(int.toUInt(), enumValues())
+
+    inline fun <reified T> of(int: UInt): Flags<T>
       where T : Flag<T>, T : Enum<T> =
       Flags(int, enumValues())
 
@@ -81,6 +96,7 @@ data class Flags<E>(
   interface Factory<E> where E : Flag<E>, E : Enum<E> {
     val NONE: Flags<E>
     fun of(bit: Int): Flags<E>
+    fun of(bit: UInt): Flags<E>
     fun of(vararg flags: E): Flags<E>
     fun of(flags: Iterable<E>): Flags<E>
   }
@@ -88,11 +104,11 @@ data class Flags<E>(
 
 infix fun <T> Flags<T>.hasFlag(which: T): Boolean where T : Enum<T>, T : Flag<T> {
   // an Undefined flag is a special case.
-  if (value == 0) return false
+  if (value == 0u) return false
   return value and which.bit == which.bit
 }
 
-infix fun <T> Flags<T>.or(other: Int): Flags<T>
+infix fun <T> Flags<T>.or(other: UInt): Flags<T>
   where T : kotlin.Enum<T>, T : Flag<T> =
   Flags(value or other)
 
@@ -104,7 +120,7 @@ infix fun <T> Flags<T>.or(other: Flags<T>): Flags<T>
   where T : kotlin.Enum<T>, T : Flag<T> =
   Flags(value or other.value)
 
-infix fun <T> Flags<T>.and(other: Int): Flags<T>
+infix fun <T> Flags<T>.and(other: UInt): Flags<T>
   where T : kotlin.Enum<T>, T : Flag<T> =
   Flags(value and other)
 
@@ -116,7 +132,7 @@ infix fun <T> Flags<T>.and(other: Flags<T>): Flags<T>
   where T : kotlin.Enum<T>, T : Flag<T> =
   Flags(value and other.value)
 
-infix operator fun <T> Flags<T>.plus(other: Int): Flags<T>
+infix operator fun <T> Flags<T>.plus(other: UInt): Flags<T>
   where T : Enum<T>, T : Flag<T> =
   Flags(value or other)
 
@@ -128,7 +144,7 @@ infix operator fun <T> Flags<T>.plus(other: Flags<T>): Flags<T>
   where T : Enum<T>, T : Flag<T> =
   Flags(value or other.value)
 
-infix operator fun <T> Flags<T>.minus(other: Int): Flags<T>
+infix operator fun <T> Flags<T>.minus(other: UInt): Flags<T>
   where T : Enum<T>, T : Flag<T> =
   Flags(value and other.inv())
 
diff --git a/lib/src/main/java/de/kuschku/libquassel/util/flag/LongFlag.kt b/lib/src/main/java/de/kuschku/libquassel/util/flag/LongFlag.kt
index 5e6e068a3..61dec8af0 100644
--- a/lib/src/main/java/de/kuschku/libquassel/util/flag/LongFlag.kt
+++ b/lib/src/main/java/de/kuschku/libquassel/util/flag/LongFlag.kt
@@ -19,29 +19,40 @@
 
 package de.kuschku.libquassel.util.flag
 
+import de.kuschku.libquassel.util.helpers.sum
+
 interface LongFlag<T> where T : Enum<T>, T : LongFlag<T> {
-  val bit: Long
+  val bit: ULong
   fun toByte() = bit.toByte()
-  fun toChar() = bit.toChar()
-  fun toDouble() = bit.toDouble()
-  fun toFloat() = bit.toFloat()
+  fun toChar() = bit.toLong().toChar()
+  fun toDouble() = bit.toLong().toDouble()
+  fun toFloat() = bit.toLong().toFloat()
   fun toInt() = bit.toInt()
-  fun toLong() = bit
+  fun toLong() = bit.toLong()
   fun toShort() = bit.toShort()
+  fun toUByte() = bit.toUByte()
+  fun toUInt() = bit.toUInt()
+  fun toULong() = bit.toULong()
+  fun toUShort() = bit.toUShort()
 }
 
 data class LongFlags<E>(
-  val value: Long,
+  val value: ULong,
   val values: Array<E>? = null
-) : Number(), Comparable<Long> where E : Enum<E>, E : LongFlag<E> {
-  override fun compareTo(other: Long) = value.compareTo(other)
+) : Number(), Comparable<ULong> where E : Enum<E>, E : LongFlag<E> {
+  override fun compareTo(other: ULong) = value.compareTo(other)
+
   override fun toByte() = value.toByte()
-  override fun toChar() = value.toChar()
-  override fun toDouble() = value.toDouble()
-  override fun toFloat() = value.toFloat()
+  override fun toChar() = value.toLong().toChar()
+  override fun toDouble() = value.toLong().toDouble()
+  override fun toFloat() = value.toLong().toFloat()
   override fun toInt() = value.toInt()
-  override fun toLong() = value
+  override fun toLong() = value.toLong()
   override fun toShort() = value.toShort()
+  fun toUByte() = value.toUByte()
+  fun toUInt() = value.toUInt()
+  fun toULong() = value.toULong()
+  fun toUShort() = value.toUShort()
 
   override fun equals(other: Any?) = when (other) {
     is LongFlags<*> -> other.value == value
@@ -50,12 +61,12 @@ data class LongFlags<E>(
   }
 
   override fun hashCode(): Int {
-    return value.toInt()
+    return value.hashCode()
   }
 
   fun enabledValues() = values?.filter { hasFlag(it) }?.toSet() ?: emptySet()
 
-  fun isEmpty() = value == 0L
+  fun isEmpty() = value == 0uL
   fun isNotEmpty() = !isEmpty()
 
   override fun toString() = if (values != null) {
@@ -67,22 +78,25 @@ data class LongFlags<E>(
   companion object {
     inline fun <reified T> of(int: Long): LongFlags<T>
       where T : LongFlag<T>, T : Enum<T> =
-      LongFlags(int,
-                enumValues())
+      LongFlags(int.toULong(), enumValues())
 
-    inline fun <reified T> of(vararg flags: LongFlag<T>): LongFlags<T>
+    inline fun <reified T> of(int: ULong): LongFlags<T>
       where T : LongFlag<T>, T : Enum<T> =
-      LongFlags(flags.map(LongFlag<T>::bit).distinct().sum(),
-                enumValues())
+      LongFlags(int, enumValues())
+
+    inline fun <reified T> of(vararg flags: T): LongFlags<T>
+      where T : LongFlag<T>, T : Enum<T> =
+      LongFlags(flags.map(LongFlag<T>::bit).distinct().sum(), enumValues())
 
     inline fun <reified T> of(flags: Iterable<T>): LongFlags<T>
       where T : LongFlag<T>, T : Enum<T> =
-      LongFlags(flags.map(LongFlag<T>::bit).distinct().sum(),
-                enumValues())
+      LongFlags(flags.map(LongFlag<T>::bit).distinct().sum(), enumValues())
   }
 
   interface Factory<E> where E : LongFlag<E>, E : Enum<E> {
+    val NONE: LongFlags<E>
     fun of(bit: Long): LongFlags<E>
+    fun of(bit: ULong): LongFlags<E>
     fun of(vararg flags: E): LongFlags<E>
     fun of(flags: Iterable<E>): LongFlags<E>
   }
@@ -90,35 +104,35 @@ data class LongFlags<E>(
 
 infix fun <T> LongFlags<T>.hasFlag(which: T): Boolean where T : Enum<T>, T : LongFlag<T> {
   // an Undefined flag is a special case.
-  if (value == 0L) return false
+  if (value == 0uL) return false
   return value and which.bit == which.bit
 }
 
-infix fun <T> LongFlags<T>.or(other: Long): LongFlags<T>
-  where T : Enum<T>, T : LongFlag<T> =
+infix fun <T> LongFlags<T>.or(other: ULong): LongFlags<T>
+  where T : kotlin.Enum<T>, T : LongFlag<T> =
   LongFlags(value or other)
 
 infix fun <T> LongFlags<T>.or(other: LongFlag<T>): LongFlags<T>
-  where T : Enum<T>, T : LongFlag<T> =
+  where T : kotlin.Enum<T>, T : LongFlag<T> =
   LongFlags(value or other.bit)
 
 infix fun <T> LongFlags<T>.or(other: LongFlags<T>): LongFlags<T>
-  where T : Enum<T>, T : LongFlag<T> =
+  where T : kotlin.Enum<T>, T : LongFlag<T> =
   LongFlags(value or other.value)
 
-infix fun <T> LongFlags<T>.and(other: Long): LongFlags<T>
-  where T : Enum<T>, T : LongFlag<T> =
+infix fun <T> LongFlags<T>.and(other: ULong): LongFlags<T>
+  where T : kotlin.Enum<T>, T : LongFlag<T> =
   LongFlags(value and other)
 
 infix fun <T> LongFlags<T>.and(other: LongFlag<T>): LongFlags<T>
-  where T : Enum<T>, T : LongFlag<T> =
+  where T : kotlin.Enum<T>, T : LongFlag<T> =
   LongFlags(value and other.bit)
 
 infix fun <T> LongFlags<T>.and(other: LongFlags<T>): LongFlags<T>
-  where T : Enum<T>, T : LongFlag<T> =
+  where T : kotlin.Enum<T>, T : LongFlag<T> =
   LongFlags(value and other.value)
 
-infix operator fun <T> LongFlags<T>.plus(other: Long): LongFlags<T>
+infix operator fun <T> LongFlags<T>.plus(other: ULong): LongFlags<T>
   where T : Enum<T>, T : LongFlag<T> =
   LongFlags(value or other)
 
@@ -130,7 +144,7 @@ infix operator fun <T> LongFlags<T>.plus(other: LongFlags<T>): LongFlags<T>
   where T : Enum<T>, T : LongFlag<T> =
   LongFlags(value or other.value)
 
-infix operator fun <T> LongFlags<T>.minus(other: Long): LongFlags<T>
+infix operator fun <T> LongFlags<T>.minus(other: ULong): LongFlags<T>
   where T : Enum<T>, T : LongFlag<T> =
   LongFlags(value and other.inv())
 
diff --git a/lib/src/main/java/de/kuschku/libquassel/util/flag/ShortFlag.kt b/lib/src/main/java/de/kuschku/libquassel/util/flag/ShortFlag.kt
index 69aeaf98f..273d8cce6 100644
--- a/lib/src/main/java/de/kuschku/libquassel/util/flag/ShortFlag.kt
+++ b/lib/src/main/java/de/kuschku/libquassel/util/flag/ShortFlag.kt
@@ -19,34 +19,40 @@
 
 package de.kuschku.libquassel.util.flag
 
-import kotlin.experimental.and
-import kotlin.experimental.inv
-import kotlin.experimental.or
-import kotlin.experimental.xor
+import de.kuschku.libquassel.util.helpers.sum
 
 interface ShortFlag<T> where T : Enum<T>, T : ShortFlag<T> {
-  val bit: Short
+  val bit: UShort
   fun toByte() = bit.toByte()
-  fun toChar() = bit.toChar()
-  fun toDouble() = bit.toDouble()
-  fun toFloat() = bit.toFloat()
+  fun toChar() = bit.toLong().toChar()
+  fun toDouble() = bit.toLong().toDouble()
+  fun toFloat() = bit.toLong().toFloat()
   fun toInt() = bit.toInt()
   fun toLong() = bit.toLong()
-  fun toShort() = bit
+  fun toShort() = bit.toShort()
+  fun toUByte() = bit.toUByte()
+  fun toUInt() = bit.toUInt()
+  fun toULong() = bit.toULong()
+  fun toUShort() = bit.toUShort()
 }
 
 data class ShortFlags<E>(
-  val value: Short,
+  val value: UShort,
   val values: Array<E>? = null
-) : Number(), Comparable<Short> where E : Enum<E>, E : ShortFlag<E> {
-  override fun compareTo(other: Short) = value.compareTo(other)
+) : Number(), Comparable<UShort> where E : Enum<E>, E : ShortFlag<E> {
+  override fun compareTo(other: UShort) = value.compareTo(other)
+
   override fun toByte() = value.toByte()
-  override fun toChar() = value.toChar()
-  override fun toDouble() = value.toDouble()
-  override fun toFloat() = value.toFloat()
+  override fun toChar() = value.toLong().toChar()
+  override fun toDouble() = value.toLong().toDouble()
+  override fun toFloat() = value.toLong().toFloat()
   override fun toInt() = value.toInt()
   override fun toLong() = value.toLong()
-  override fun toShort() = value
+  override fun toShort() = value.toShort()
+  fun toUByte() = value.toUByte()
+  fun toUInt() = value.toUInt()
+  fun toULong() = value.toULong()
+  fun toUShort() = value.toUShort()
 
   override fun equals(other: Any?) = when (other) {
     is ShortFlags<*> -> other.value == value
@@ -55,12 +61,12 @@ data class ShortFlags<E>(
   }
 
   override fun hashCode(): Int {
-    return value.toInt()
+    return value.hashCode()
   }
 
   fun enabledValues() = values?.filter { hasFlag(it) }?.toSet() ?: emptySet()
 
-  fun isEmpty() = value == 0.toShort()
+  fun isEmpty() = value == 0u.toUShort()
   fun isNotEmpty() = !isEmpty()
 
   override fun toString() = if (values != null) {
@@ -71,20 +77,26 @@ data class ShortFlags<E>(
 
   companion object {
     inline fun <reified T> of(int: Short): ShortFlags<T>
+      where T : ShortFlag<T>, T : Enum<T> =
+      ShortFlags(int.toUShort(), enumValues())
+
+    inline fun <reified T> of(int: UShort): ShortFlags<T>
       where T : ShortFlag<T>, T : Enum<T> =
       ShortFlags(int, enumValues())
 
-    inline fun <reified T> of(vararg flags: ShortFlag<T>): ShortFlags<T>
+    inline fun <reified T> of(vararg flags: T): ShortFlags<T>
       where T : ShortFlag<T>, T : Enum<T> =
-      ShortFlags(flags.map(ShortFlag<T>::bit).distinct().sum().toShort(), enumValues())
+      ShortFlags(flags.map(ShortFlag<T>::bit).distinct().sum().toUShort(), enumValues())
 
     inline fun <reified T> of(flags: Iterable<T>): ShortFlags<T>
       where T : ShortFlag<T>, T : Enum<T> =
-      ShortFlags(flags.map(ShortFlag<T>::bit).distinct().sum().toShort(), enumValues())
+      ShortFlags(flags.map(ShortFlag<T>::bit).distinct().sum().toUShort(), enumValues())
   }
 
   interface Factory<E> where E : ShortFlag<E>, E : Enum<E> {
+    val NONE: ShortFlags<E>
     fun of(bit: Short): ShortFlags<E>
+    fun of(bit: UShort): ShortFlags<E>
     fun of(vararg flags: E): ShortFlags<E>
     fun of(flags: Iterable<E>): ShortFlags<E>
   }
@@ -92,12 +104,11 @@ data class ShortFlags<E>(
 
 infix fun <T> ShortFlags<T>.hasFlag(which: T): Boolean where T : Enum<T>, T : ShortFlag<T> {
   // an Undefined flag is a special case.
-  if (value == 0.toShort() || (value > 0 && which.bit == 0.toShort())) return false
-
+  if (value == 0u.toUShort()) return false
   return value and which.bit == which.bit
 }
 
-infix fun <T> ShortFlags<T>.or(other: Short): ShortFlags<T>
+infix fun <T> ShortFlags<T>.or(other: UShort): ShortFlags<T>
   where T : kotlin.Enum<T>, T : ShortFlag<T> =
   ShortFlags(value or other)
 
@@ -109,7 +120,7 @@ infix fun <T> ShortFlags<T>.or(other: ShortFlags<T>): ShortFlags<T>
   where T : kotlin.Enum<T>, T : ShortFlag<T> =
   ShortFlags(value or other.value)
 
-infix fun <T> ShortFlags<T>.and(other: Short): ShortFlags<T>
+infix fun <T> ShortFlags<T>.and(other: UShort): ShortFlags<T>
   where T : kotlin.Enum<T>, T : ShortFlag<T> =
   ShortFlags(value and other)
 
@@ -121,7 +132,7 @@ infix fun <T> ShortFlags<T>.and(other: ShortFlags<T>): ShortFlags<T>
   where T : kotlin.Enum<T>, T : ShortFlag<T> =
   ShortFlags(value and other.value)
 
-infix operator fun <T> ShortFlags<T>.plus(other: Short): ShortFlags<T>
+infix operator fun <T> ShortFlags<T>.plus(other: UShort): ShortFlags<T>
   where T : Enum<T>, T : ShortFlag<T> =
   ShortFlags(value or other)
 
@@ -133,7 +144,7 @@ infix operator fun <T> ShortFlags<T>.plus(other: ShortFlags<T>): ShortFlags<T>
   where T : Enum<T>, T : ShortFlag<T> =
   ShortFlags(value or other.value)
 
-infix operator fun <T> ShortFlags<T>.minus(other: Short): ShortFlags<T>
+infix operator fun <T> ShortFlags<T>.minus(other: UShort): ShortFlags<T>
   where T : Enum<T>, T : ShortFlag<T> =
   ShortFlags(value and other.inv())
 
diff --git a/lib/src/main/java/de/kuschku/libquassel/util/helpers/CollectionHelper.kt b/lib/src/main/java/de/kuschku/libquassel/util/helpers/CollectionHelper.kt
new file mode 100644
index 000000000..47cc6701a
--- /dev/null
+++ b/lib/src/main/java/de/kuschku/libquassel/util/helpers/CollectionHelper.kt
@@ -0,0 +1,50 @@
+package de.kuschku.libquassel.util.helpers
+
+
+/**
+ * Returns the sum of all elements in the collection.
+ */
+@kotlin.jvm.JvmName("sumOfUByte")
+fun Iterable<UByte>.sum(): UInt {
+  var sum: UInt = 0u
+  for (element in this) {
+    sum += element
+  }
+  return sum
+}
+
+/**
+ * Returns the sum of all elements in the collection.
+ */
+@kotlin.jvm.JvmName("sumOfUShort")
+fun Iterable<UShort>.sum(): UInt {
+  var sum: UInt = 0u
+  for (element in this) {
+    sum += element
+  }
+  return sum
+}
+
+/**
+ * Returns the sum of all elements in the collection.
+ */
+@kotlin.jvm.JvmName("sumOfUInt")
+fun Iterable<UInt>.sum(): UInt {
+  var sum: UInt = 0u
+  for (element in this) {
+    sum += element
+  }
+  return sum
+}
+
+/**
+ * Returns the sum of all elements in the collection.
+ */
+@kotlin.jvm.JvmName("sumOfULong")
+fun Iterable<ULong>.sum(): ULong {
+  var sum: ULong = 0uL
+  for (element in this) {
+    sum += element
+  }
+  return sum
+}
diff --git a/lib/src/test/java/de/kuschku/libquassel/quassel/syncables/AliasManagerTest.kt b/lib/src/test/java/de/kuschku/libquassel/quassel/syncables/AliasManagerTest.kt
index 0113ffaab..f98c1fa7d 100644
--- a/lib/src/test/java/de/kuschku/libquassel/quassel/syncables/AliasManagerTest.kt
+++ b/lib/src/test/java/de/kuschku/libquassel/quassel/syncables/AliasManagerTest.kt
@@ -37,7 +37,10 @@ class AliasManagerTest {
 
     val copy = original.copy()
     copy.fromVariantMap(roundTrip(VariantMapSerializer, original.toVariantMap()))
-    assert(original.isEqual(copy))
+    assert(original.isEqual(copy)) {
+      System.err.println("Original:\n$original")
+      System.err.println("Copy:\n$copy")
+    }
   }
 
   @Test
@@ -47,7 +50,10 @@ class AliasManagerTest {
 
     val copy = original.copy()
     copy.fromVariantMap(original.toVariantMap())
-    assert(original.isEqual(copy))
+    assert(original.isEqual(copy)) {
+      System.err.println("Original:\n$original")
+      System.err.println("Copy:\n$copy")
+    }
   }
 
   @Test
diff --git a/lib/src/test/java/de/kuschku/libquassel/quassel/syncables/BufferViewConfigTest.kt b/lib/src/test/java/de/kuschku/libquassel/quassel/syncables/BufferViewConfigTest.kt
index 517945997..fe468b734 100644
--- a/lib/src/test/java/de/kuschku/libquassel/quassel/syncables/BufferViewConfigTest.kt
+++ b/lib/src/test/java/de/kuschku/libquassel/quassel/syncables/BufferViewConfigTest.kt
@@ -29,9 +29,9 @@ import org.junit.Test
 class BufferViewConfigTest {
   @Test
   fun testSerialization() {
-    val original = BufferViewConfig(randomUInt(), SignalProxy.NULL)
+    val original = BufferViewConfig(randomInt(), SignalProxy.NULL)
     original.setBufferViewName(randomString())
-    original.setNetworkId(randomUInt())
+    original.setNetworkId(randomInt())
     original.setAddNewBuffersAutomatically(randomBoolean())
     original.setSortAlphabetically(randomBoolean())
     original.setHideInactiveNetworks(randomBoolean())
@@ -44,14 +44,17 @@ class BufferViewConfigTest {
 
     val copy = original.copy()
     copy.fromVariantMap(roundTrip(VariantMapSerializer, original.toVariantMap()))
-    assert(original.isEqual(copy))
+    assert(original.isEqual(copy)) {
+      System.err.println("Original:\n$original")
+      System.err.println("Copy:\n$copy")
+    }
   }
 
   @Test
   fun testCopy() {
-    val original = BufferViewConfig(randomUInt(), SignalProxy.NULL)
+    val original = BufferViewConfig(randomInt(), SignalProxy.NULL)
     original.setBufferViewName(randomString())
-    original.setNetworkId(randomUInt())
+    original.setNetworkId(randomInt())
     original.setAddNewBuffersAutomatically(randomBoolean())
     original.setSortAlphabetically(randomBoolean())
     original.setHideInactiveNetworks(randomBoolean())
@@ -64,6 +67,9 @@ class BufferViewConfigTest {
 
     val copy = original.copy()
     copy.fromVariantMap(original.toVariantMap())
-    assert(original.isEqual(copy))
+    assert(original.isEqual(copy)) {
+      System.err.println("Original:\n$original")
+      System.err.println("Copy:\n$copy")
+    }
   }
 }
diff --git a/lib/src/test/java/de/kuschku/libquassel/quassel/syncables/HighlightRuleManagerTest.kt b/lib/src/test/java/de/kuschku/libquassel/quassel/syncables/HighlightRuleManagerTest.kt
index 902e30f19..cd429d731 100644
--- a/lib/src/test/java/de/kuschku/libquassel/quassel/syncables/HighlightRuleManagerTest.kt
+++ b/lib/src/test/java/de/kuschku/libquassel/quassel/syncables/HighlightRuleManagerTest.kt
@@ -66,7 +66,10 @@ class HighlightRuleManagerTest {
 
     val copy = original.copy()
     copy.fromVariantMap(roundTrip(VariantMapSerializer, original.toVariantMap()))
-    assert(original.isEqual(copy))
+    assert(original.isEqual(copy)) {
+      System.err.println("Original:\n$original")
+      System.err.println("Copy:\n$copy")
+    }
   }
 
   @Test
@@ -109,6 +112,9 @@ class HighlightRuleManagerTest {
 
     val copy = original.copy()
     copy.fromVariantMap(original.toVariantMap())
-    assert(original.isEqual(copy))
+    assert(original.isEqual(copy)) {
+      System.err.println("Original:\n$original")
+      System.err.println("Copy:\n$copy")
+    }
   }
 }
diff --git a/lib/src/test/java/de/kuschku/libquassel/quassel/syncables/IdentityTest.kt b/lib/src/test/java/de/kuschku/libquassel/quassel/syncables/IdentityTest.kt
index 260fd485e..d23fdb3c7 100644
--- a/lib/src/test/java/de/kuschku/libquassel/quassel/syncables/IdentityTest.kt
+++ b/lib/src/test/java/de/kuschku/libquassel/quassel/syncables/IdentityTest.kt
@@ -21,8 +21,8 @@ package de.kuschku.libquassel.quassel.syncables
 
 import de.kuschku.libquassel.protocol.primitive.serializer.VariantMapSerializer
 import de.kuschku.libquassel.session.SignalProxy
+import de.kuschku.libquassel.util.randomInt
 import de.kuschku.libquassel.util.randomString
-import de.kuschku.libquassel.util.randomUInt
 import de.kuschku.libquassel.util.roundTrip
 import org.junit.Test
 
@@ -30,7 +30,7 @@ class IdentityTest {
   @Test
   fun testSerialization() {
     val original = Identity(SignalProxy.NULL)
-    original.setId(randomUInt())
+    original.setId(randomInt())
     original.setIdentityName(randomString())
     original.setRealName(randomString())
     original.setNicks(listOf(
@@ -41,13 +41,16 @@ class IdentityTest {
 
     val copy = original.copy()
     copy.fromVariantMap(roundTrip(VariantMapSerializer, original.toVariantMap()))
-    assert(original.isEqual(copy))
+    assert(original.isEqual(copy)) {
+      System.err.println("Original:\n$original")
+      System.err.println("Copy:\n$copy")
+    }
   }
 
   @Test
   fun testCopy() {
     val original = Identity(SignalProxy.NULL)
-    original.setId(randomUInt())
+    original.setId(randomInt())
     original.setIdentityName(randomString())
     original.setRealName(randomString())
     original.setNicks(listOf(
@@ -58,6 +61,9 @@ class IdentityTest {
 
     val copy = original.copy()
     copy.fromVariantMap(original.toVariantMap())
-    assert(original.isEqual(copy))
+    assert(original.isEqual(copy)) {
+      System.err.println("Original:\n$original")
+      System.err.println("Copy:\n$copy")
+    }
   }
 }
diff --git a/lib/src/test/java/de/kuschku/libquassel/quassel/syncables/IgnoreListManagerTest.kt b/lib/src/test/java/de/kuschku/libquassel/quassel/syncables/IgnoreListManagerTest.kt
index e68af217b..0d53e1c5c 100644
--- a/lib/src/test/java/de/kuschku/libquassel/quassel/syncables/IgnoreListManagerTest.kt
+++ b/lib/src/test/java/de/kuschku/libquassel/quassel/syncables/IgnoreListManagerTest.kt
@@ -57,7 +57,10 @@ class IgnoreListManagerTest {
 
     val copy = original.copy()
     copy.fromVariantMap(roundTrip(VariantMapSerializer, original.toVariantMap()))
-    assert(original.isEqual(copy))
+    assert(original.isEqual(copy)) {
+      System.err.println("Original:\n$original")
+      System.err.println("Copy:\n$copy")
+    }
   }
 
   @Test
@@ -88,6 +91,9 @@ class IgnoreListManagerTest {
 
     val copy = original.copy()
     copy.fromVariantMap(original.toVariantMap())
-    assert(original.isEqual(copy))
+    assert(original.isEqual(copy)) {
+      System.err.println("Original:\n$original")
+      System.err.println("Copy:\n$copy")
+    }
   }
 }
diff --git a/lib/src/test/java/de/kuschku/libquassel/quassel/syncables/NetworkConfigTest.kt b/lib/src/test/java/de/kuschku/libquassel/quassel/syncables/NetworkConfigTest.kt
index 681f522ea..4d020d6c2 100644
--- a/lib/src/test/java/de/kuschku/libquassel/quassel/syncables/NetworkConfigTest.kt
+++ b/lib/src/test/java/de/kuschku/libquassel/quassel/syncables/NetworkConfigTest.kt
@@ -22,42 +22,49 @@ package de.kuschku.libquassel.quassel.syncables
 import de.kuschku.libquassel.protocol.primitive.serializer.VariantMapSerializer
 import de.kuschku.libquassel.session.SignalProxy
 import de.kuschku.libquassel.util.randomBoolean
-import de.kuschku.libquassel.util.randomUInt
+import de.kuschku.libquassel.util.randomInt
 import de.kuschku.libquassel.util.roundTrip
 import org.junit.Test
+import kotlin.math.abs
 
 class NetworkConfigTest {
   @Test
   fun testSerialization() {
     val original = NetworkConfig(SignalProxy.NULL)
     original.setPingTimeoutEnabled(randomBoolean())
-    original.setPingInterval(randomUInt())
-    original.setMaxPingCount(randomUInt())
+    original.setPingInterval(abs(randomInt()))
+    original.setMaxPingCount(abs(randomInt()))
     original.setAutoWhoEnabled(randomBoolean())
-    original.setAutoWhoInterval(randomUInt())
-    original.setAutoWhoNickLimit(randomUInt())
-    original.setAutoWhoDelay(randomUInt())
+    original.setAutoWhoInterval(abs(randomInt()))
+    original.setAutoWhoNickLimit(abs(randomInt()))
+    original.setAutoWhoDelay(abs(randomInt()))
     original.setStandardCtcp(randomBoolean())
 
     val copy = original.copy()
     copy.fromVariantMap(roundTrip(VariantMapSerializer, original.toVariantMap()))
-    assert(original.isEqual(copy))
+    assert(original.isEqual(copy)) {
+      System.err.println("Original:\n$original")
+      System.err.println("Copy:\n$copy")
+    }
   }
 
   @Test
   fun testCopy() {
     val original = NetworkConfig(SignalProxy.NULL)
     original.setPingTimeoutEnabled(randomBoolean())
-    original.setPingInterval(randomUInt())
-    original.setMaxPingCount(randomUInt())
+    original.setPingInterval(abs(randomInt()))
+    original.setMaxPingCount(abs(randomInt()))
     original.setAutoWhoEnabled(randomBoolean())
-    original.setAutoWhoInterval(randomUInt())
-    original.setAutoWhoNickLimit(randomUInt())
-    original.setAutoWhoDelay(randomUInt())
+    original.setAutoWhoInterval(abs(randomInt()))
+    original.setAutoWhoNickLimit(abs(randomInt()))
+    original.setAutoWhoDelay(abs(randomInt()))
     original.setStandardCtcp(randomBoolean())
 
     val copy = original.copy()
     copy.fromVariantMap(original.toVariantMap())
-    assert(original.isEqual(copy))
+    assert(original.isEqual(copy)) {
+      System.err.println("Original:\n$original")
+      System.err.println("Copy:\n$copy")
+    }
   }
 }
diff --git a/lib/src/test/java/de/kuschku/libquassel/quassel/syncables/NetworkTest.kt b/lib/src/test/java/de/kuschku/libquassel/quassel/syncables/NetworkTest.kt
index 1be9bb428..ffb0309bf 100644
--- a/lib/src/test/java/de/kuschku/libquassel/quassel/syncables/NetworkTest.kt
+++ b/lib/src/test/java/de/kuschku/libquassel/quassel/syncables/NetworkTest.kt
@@ -28,9 +28,9 @@ import org.junit.Test
 class NetworkTest {
   @Test
   fun testSerialization() {
-    val original = Network(randomUInt(), SignalProxy.NULL)
+    val original = Network(randomInt(), SignalProxy.NULL)
     original.setNetworkName(randomString())
-    original.setIdentity(randomUInt())
+    original.setIdentity(randomInt())
     original.setActualServerList(listOf(
       INetwork.Server(
         host = randomString(),
@@ -84,7 +84,7 @@ class NetworkTest {
     original.addSupport("EXTBAN", ",ABCNOQRSTUcjmprsz")
     original.addSupport("FNC", null)
     original.addSupport("INVEX", "I")
-    for (i in 0 until randomUByte()) {
+    for (i in 0 until 8) {
       original.newIrcUser(randomString() + "!" + randomString() + "@" + randomString()).apply {
         setUser(randomString())
         setHost(randomString())
@@ -108,7 +108,7 @@ class NetworkTest {
         ).toString())
       }
     }
-    for (i in 0 until randomUByte()) {
+    for (i in 0 until 8) {
       original.newIrcChannel(randomString(), mapOf()).apply {
         setTopic(randomString())
         setPassword(randomString())
@@ -147,14 +147,17 @@ class NetworkTest {
 
     val copy = original.copy()
     copy.fromVariantMap(roundTrip(VariantMapSerializer, original.toVariantMap()))
-    assert(original.isEqual(copy))
+    assert(original.isEqual(copy)) {
+      System.err.println("Original:\n$original")
+      System.err.println("Copy:\n$copy")
+    }
   }
 
   @Test
   fun testCopy() {
-    val original = Network(randomUInt(), SignalProxy.NULL)
+    val original = Network(randomInt(), SignalProxy.NULL)
     original.setNetworkName(randomString())
-    original.setIdentity(randomUInt())
+    original.setIdentity(randomInt())
     original.setActualServerList(listOf(
       INetwork.Server(
         host = randomString(),
@@ -208,7 +211,7 @@ class NetworkTest {
     original.addSupport("EXTBAN", ",ABCNOQRSTUcjmprsz")
     original.addSupport("FNC", null)
     original.addSupport("INVEX", "I")
-    for (i in 0 until randomUByte()) {
+    for (i in 0 until 8) {
       original.newIrcUser(randomString() + "!" + randomString() + "@" + randomString()).apply {
         setUser(randomString())
         setHost(randomString())
@@ -232,7 +235,7 @@ class NetworkTest {
         ).toString())
       }
     }
-    for (i in 0 until randomUByte()) {
+    for (i in 0 until 8) {
       original.newIrcChannel(randomString(), mapOf()).apply {
         setTopic(randomString())
         setPassword(randomString())
@@ -271,7 +274,10 @@ class NetworkTest {
 
     val copy = original.copy()
     copy.fromVariantMap(original.toVariantMap())
-    assert(original.isEqual(copy))
+    assert(original.isEqual(copy)) {
+      System.err.println("Original:\n$original")
+      System.err.println("Copy:\n$copy")
+    }
   }
 
   companion object {
diff --git a/lib/src/test/java/de/kuschku/libquassel/quassel/syncables/interfaces/INetworkInfoTest.kt b/lib/src/test/java/de/kuschku/libquassel/quassel/syncables/interfaces/INetworkInfoTest.kt
index 6176c8e37..b3be2f176 100644
--- a/lib/src/test/java/de/kuschku/libquassel/quassel/syncables/interfaces/INetworkInfoTest.kt
+++ b/lib/src/test/java/de/kuschku/libquassel/quassel/syncables/interfaces/INetworkInfoTest.kt
@@ -20,6 +20,7 @@
 package de.kuschku.libquassel.quassel.syncables.interfaces
 
 import de.kuschku.libquassel.protocol.primitive.serializer.VariantMapSerializer
+import de.kuschku.libquassel.quassel.syncables.interfaces.INetwork.PortDefaults.PORT_PLAINTEXT
 import de.kuschku.libquassel.util.roundTrip
 import org.junit.Assert.assertEquals
 import org.junit.Test
@@ -33,7 +34,7 @@ class INetworkInfoTest {
       serverList = listOf(
         INetwork.Server(
           host = "irc.quakenet.org",
-          port = 6667
+          port = PORT_PLAINTEXT.port
         )
       )
     )
@@ -50,7 +51,7 @@ class INetworkInfoTest {
       serverList = listOf(
         INetwork.Server(
           host = "irc.quakenet.org",
-          port = 6667
+          port = PORT_PLAINTEXT.port
         )
       )
     )
diff --git a/lib/src/test/java/de/kuschku/libquassel/util/RandomHelpers.kt b/lib/src/test/java/de/kuschku/libquassel/util/RandomHelpers.kt
index 0f71164b6..c3319d935 100644
--- a/lib/src/test/java/de/kuschku/libquassel/util/RandomHelpers.kt
+++ b/lib/src/test/java/de/kuschku/libquassel/util/RandomHelpers.kt
@@ -19,9 +19,6 @@
 
 package de.kuschku.libquassel.util
 
-import de.kuschku.libquassel.protocol.UByte
-import de.kuschku.libquassel.protocol.UInt
-import de.kuschku.libquassel.protocol.UShort
 import org.threeten.bp.Instant
 import java.nio.charset.Charset
 import java.util.*
@@ -30,16 +27,17 @@ val random = Random()
 
 fun Any?.randomBoolean(): Boolean = random.nextBoolean()
 
-fun Any?.randomByte(): Byte = random.nextInt(2 shl 8).toByte()
-fun Any?.randomUByte(): UByte = random.nextInt(Byte.MAX_VALUE.toInt()).toByte()
+fun Any?.randomByte(): Byte = random.nextInt().toByte()
+fun Any?.randomUByte(): UByte = random.nextInt().toUByte()
 
-fun Any?.randomShort(): Short = random.nextInt(2 shl 16).toShort()
-fun Any?.randomUShort(): UShort = random.nextInt(Short.MAX_VALUE.toInt()).toShort()
+fun Any?.randomShort(): Short = random.nextInt().toShort()
+fun Any?.randomUShort(): UShort = random.nextInt().toUShort()
 
 fun Any?.randomInt(): Int = random.nextInt()
-fun Any?.randomUInt(): UInt = random.nextInt(Int.MAX_VALUE)
+fun Any?.randomUInt(): UInt = random.nextInt().toUInt()
 
 fun Any?.randomLong(): Long = random.nextLong()
+fun Any?.randomULong(): ULong = random.nextLong().toULong()
 
 fun Any?.randomString(): String = UUID.randomUUID().toString()
 
-- 
GitLab