diff --git a/build.gradle.kts b/build.gradle.kts
index 8316f8616102c0f4ad1ac32aef58e50bd5dbc2ea..e28ee393ae0c8386d26499b35dad767286a6074a 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -15,6 +15,7 @@ plugins {
   id("org.jlleitschuh.gradle.ktlint") version "10.0.0"
   id("org.jetbrains.dokka") version "1.4.20"
   id("maven-publish")
+  id("jacoco")
 }
 
 repositories {
@@ -48,6 +49,20 @@ tasks.test {
   useJUnitPlatform()
 }
 
+jacoco {
+  toolVersion = "0.8.3"
+}
+
+tasks.getByName<JacocoReport>("jacocoTestReport") {
+  reports {
+    sourceDirectories.from(fileTree("src/main/kotlin"))
+    xml.destination = File("$buildDir/reports/jacoco/report.xml")
+    html.isEnabled = true
+    xml.isEnabled = true
+    csv.isEnabled = false
+  }
+}
+
 tasks.withType<KotlinCompile> {
   kotlinOptions {
     jvmTarget = "1.8"
diff --git a/src/test/kotlin/de/justjanne/bitflags/NoneTest.kt b/src/test/kotlin/de/justjanne/bitflags/NoneTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..25c940d0d89b2fe61970f48c2ddfb66b18e0efc4
--- /dev/null
+++ b/src/test/kotlin/de/justjanne/bitflags/NoneTest.kt
@@ -0,0 +1,99 @@
+/*
+ * Kotlin Bitflags
+ * Copyright (c) 2021 Janne Mareike Koschinski
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public License,
+ * v. 2.0. If a copy of the MPL was not distributed with this file, You can
+ * obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package de.justjanne.bitflags
+
+import de.justjanne.bitflags.test.MessageFlagByte
+import de.justjanne.bitflags.test.MessageFlagInt
+import de.justjanne.bitflags.test.MessageFlagLong
+import de.justjanne.bitflags.test.MessageFlagShort
+import de.justjanne.bitflags.test.MessageFlagUByte
+import de.justjanne.bitflags.test.MessageFlagUInt
+import de.justjanne.bitflags.test.MessageFlagULong
+import de.justjanne.bitflags.test.MessageFlagUShort
+import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+
+class NoneTest {
+  @Test
+  fun `has no set bits`() {
+    assertEquals(0, MessageFlagByte.none().toBits())
+    assertEquals(0u, MessageFlagUByte.none().toBits())
+    assertEquals(0, MessageFlagShort.none().toBits())
+    assertEquals(0u, MessageFlagUShort.none().toBits())
+    assertEquals(0, MessageFlagInt.none().toBits())
+    assertEquals(0u, MessageFlagUInt.none().toBits())
+    assertEquals(0, MessageFlagLong.none().toBits())
+    assertEquals(0u, MessageFlagULong.none().toBits())
+  }
+
+  @Test
+  fun `has no entries`() {
+    assertEquals(0, MessageFlagByte.none().size)
+    assertEquals(0, MessageFlagUByte.none().size)
+    assertEquals(0, MessageFlagShort.none().size)
+    assertEquals(0, MessageFlagUShort.none().size)
+    assertEquals(0, MessageFlagInt.none().size)
+    assertEquals(0, MessageFlagUInt.none().size)
+    assertEquals(0, MessageFlagLong.none().size)
+    assertEquals(0, MessageFlagULong.none().size)
+  }
+
+  @Test
+  fun `has no flag set`() {
+    assertFalse(MessageFlagByte.none().contains(MessageFlagByte.Self))
+    assertFalse(MessageFlagByte.none().contains(MessageFlagByte.Highlight))
+    assertFalse(MessageFlagByte.none().contains(MessageFlagByte.ServerMsg))
+    assertFalse(MessageFlagByte.none().contains(MessageFlagByte.Redirected))
+    assertFalse(MessageFlagByte.none().contains(MessageFlagByte.Backlog))
+
+    assertFalse(MessageFlagUByte.none().contains(MessageFlagUByte.Self))
+    assertFalse(MessageFlagUByte.none().contains(MessageFlagUByte.Highlight))
+    assertFalse(MessageFlagUByte.none().contains(MessageFlagUByte.ServerMsg))
+    assertFalse(MessageFlagUByte.none().contains(MessageFlagUByte.Redirected))
+    assertFalse(MessageFlagUByte.none().contains(MessageFlagUByte.Backlog))
+
+    assertFalse(MessageFlagShort.none().contains(MessageFlagShort.Self))
+    assertFalse(MessageFlagShort.none().contains(MessageFlagShort.Highlight))
+    assertFalse(MessageFlagShort.none().contains(MessageFlagShort.ServerMsg))
+    assertFalse(MessageFlagShort.none().contains(MessageFlagShort.Redirected))
+    assertFalse(MessageFlagShort.none().contains(MessageFlagShort.Backlog))
+
+    assertFalse(MessageFlagUShort.none().contains(MessageFlagUShort.Self))
+    assertFalse(MessageFlagUShort.none().contains(MessageFlagUShort.Highlight))
+    assertFalse(MessageFlagUShort.none().contains(MessageFlagUShort.ServerMsg))
+    assertFalse(MessageFlagUShort.none().contains(MessageFlagUShort.Redirected))
+    assertFalse(MessageFlagUShort.none().contains(MessageFlagUShort.Backlog))
+
+    assertFalse(MessageFlagInt.none().contains(MessageFlagInt.Self))
+    assertFalse(MessageFlagInt.none().contains(MessageFlagInt.Highlight))
+    assertFalse(MessageFlagInt.none().contains(MessageFlagInt.ServerMsg))
+    assertFalse(MessageFlagInt.none().contains(MessageFlagInt.Redirected))
+    assertFalse(MessageFlagInt.none().contains(MessageFlagInt.Backlog))
+
+    assertFalse(MessageFlagUInt.none().contains(MessageFlagUInt.Self))
+    assertFalse(MessageFlagUInt.none().contains(MessageFlagUInt.Highlight))
+    assertFalse(MessageFlagUInt.none().contains(MessageFlagUInt.ServerMsg))
+    assertFalse(MessageFlagUInt.none().contains(MessageFlagUInt.Redirected))
+    assertFalse(MessageFlagUInt.none().contains(MessageFlagUInt.Backlog))
+
+    assertFalse(MessageFlagLong.none().contains(MessageFlagLong.Self))
+    assertFalse(MessageFlagLong.none().contains(MessageFlagLong.Highlight))
+    assertFalse(MessageFlagLong.none().contains(MessageFlagLong.ServerMsg))
+    assertFalse(MessageFlagLong.none().contains(MessageFlagLong.Redirected))
+    assertFalse(MessageFlagLong.none().contains(MessageFlagLong.Backlog))
+
+    assertFalse(MessageFlagULong.none().contains(MessageFlagULong.Self))
+    assertFalse(MessageFlagULong.none().contains(MessageFlagULong.Highlight))
+    assertFalse(MessageFlagULong.none().contains(MessageFlagULong.ServerMsg))
+    assertFalse(MessageFlagULong.none().contains(MessageFlagULong.Redirected))
+    assertFalse(MessageFlagULong.none().contains(MessageFlagULong.Backlog))
+  }
+}
diff --git a/src/test/kotlin/de/justjanne/bitflags/ToBitsTest.kt b/src/test/kotlin/de/justjanne/bitflags/ToBitsTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..d12c488bbb481678382636a841ccea1bbac01fe2
--- /dev/null
+++ b/src/test/kotlin/de/justjanne/bitflags/ToBitsTest.kt
@@ -0,0 +1,65 @@
+/*
+ * Kotlin Bitflags
+ * Copyright (c) 2021 Janne Mareike Koschinski
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public License,
+ * v. 2.0. If a copy of the MPL was not distributed with this file, You can
+ * obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package de.justjanne.bitflags
+
+import de.justjanne.bitflags.test.MessageFlagByte
+import de.justjanne.bitflags.test.MessageFlagInt
+import de.justjanne.bitflags.test.MessageFlagLong
+import de.justjanne.bitflags.test.MessageFlagShort
+import de.justjanne.bitflags.test.MessageFlagUByte
+import de.justjanne.bitflags.test.MessageFlagUInt
+import de.justjanne.bitflags.test.MessageFlagULong
+import de.justjanne.bitflags.test.MessageFlagUShort
+import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
+
+class ToBitsTest {
+  @Test
+  fun `treats null as none`() {
+    val valueByte: Set<MessageFlagByte>? = null
+    assertEquals(0, valueByte.toBits())
+
+    val valueUByte: Set<MessageFlagUByte>? = null
+    assertEquals(0u, valueUByte.toBits())
+
+    val valueShort: Set<MessageFlagShort>? = null
+    assertEquals(0, valueShort.toBits())
+
+    val valueUShort: Set<MessageFlagUShort>? = null
+    assertEquals(0u, valueUShort.toBits())
+
+    val valueInt: Set<MessageFlagInt>? = null
+    assertEquals(0, valueInt.toBits())
+
+    val valueUInt: Set<MessageFlagUInt>? = null
+    assertEquals(0u, valueUInt.toBits())
+
+    val valueLong: Set<MessageFlagLong>? = null
+    assertEquals(0, valueLong.toBits())
+
+    val valueULong: Set<MessageFlagULong>? = null
+    assertEquals(0u, valueULong.toBits())
+  }
+
+  @Test
+  fun `contains all set bits`() {
+    assertEquals(0x14, MessageFlagByte.of(MessageFlagByte.Redirected, MessageFlagByte.Backlog).toBits())
+    assertEquals(0x14u, MessageFlagUByte.of(MessageFlagUByte.Redirected, MessageFlagUByte.Backlog).toBits())
+
+    assertEquals(0x14, MessageFlagShort.of(MessageFlagShort.Redirected, MessageFlagShort.Backlog).toBits())
+    assertEquals(0x14u, MessageFlagUShort.of(MessageFlagUShort.Redirected, MessageFlagUShort.Backlog).toBits())
+
+    assertEquals(0x14, MessageFlagInt.of(MessageFlagInt.Redirected, MessageFlagInt.Backlog).toBits())
+    assertEquals(0x14u, MessageFlagUInt.of(MessageFlagUInt.Redirected, MessageFlagUInt.Backlog).toBits())
+
+    assertEquals(0x14, MessageFlagLong.of(MessageFlagLong.Redirected, MessageFlagLong.Backlog).toBits())
+    assertEquals(0x14u, MessageFlagULong.of(MessageFlagULong.Redirected, MessageFlagULong.Backlog).toBits())
+  }
+}
diff --git a/src/test/kotlin/de/justjanne/bitflags/ToEnumSetTest.kt b/src/test/kotlin/de/justjanne/bitflags/ToEnumSetTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..0e5dfeb8e0659e29136563b5b17e97d15cea1b8b
--- /dev/null
+++ b/src/test/kotlin/de/justjanne/bitflags/ToEnumSetTest.kt
@@ -0,0 +1,67 @@
+/*
+ * Kotlin Bitflags
+ * Copyright (c) 2021 Janne Mareike Koschinski
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public License,
+ * v. 2.0. If a copy of the MPL was not distributed with this file, You can
+ * obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package de.justjanne.bitflags
+
+import de.justjanne.bitflags.test.MessageFlagByte
+import de.justjanne.bitflags.test.MessageFlagInt
+import de.justjanne.bitflags.test.MessageFlagLong
+import de.justjanne.bitflags.test.MessageFlagShort
+import de.justjanne.bitflags.test.MessageFlagUByte
+import de.justjanne.bitflags.test.MessageFlagUInt
+import de.justjanne.bitflags.test.MessageFlagULong
+import de.justjanne.bitflags.test.MessageFlagUShort
+import org.junit.jupiter.api.Test
+import java.util.EnumSet
+import kotlin.test.assertEquals
+
+class ToEnumSetTest {
+  @Test
+  fun `contains same values`() {
+    val listByte = listOf(MessageFlagByte.Redirected, MessageFlagByte.Backlog)
+    assertEquals(EnumSet.copyOf(listByte), listByte.toEnumSet())
+    val arrayByte = arrayOf(MessageFlagByte.Redirected, MessageFlagByte.Backlog)
+    assertEquals(EnumSet.copyOf(arrayByte.toList()), listByte.toEnumSet())
+
+    val listUByte = listOf(MessageFlagUByte.Redirected, MessageFlagUByte.Backlog)
+    assertEquals(EnumSet.copyOf(listUByte), listUByte.toEnumSet())
+    val arrayUByte = arrayOf(MessageFlagUByte.Redirected, MessageFlagUByte.Backlog)
+    assertEquals(EnumSet.copyOf(arrayUByte.toList()), listUByte.toEnumSet())
+
+    val listShort = listOf(MessageFlagShort.Redirected, MessageFlagShort.Backlog)
+    assertEquals(EnumSet.copyOf(listShort), listShort.toEnumSet())
+    val arrayShort = arrayOf(MessageFlagShort.Redirected, MessageFlagShort.Backlog)
+    assertEquals(EnumSet.copyOf(arrayShort.toList()), listShort.toEnumSet())
+
+    val listUShort = listOf(MessageFlagUShort.Redirected, MessageFlagUShort.Backlog)
+    assertEquals(EnumSet.copyOf(listUShort), listUShort.toEnumSet())
+    val arrayUShort = arrayOf(MessageFlagUShort.Redirected, MessageFlagUShort.Backlog)
+    assertEquals(EnumSet.copyOf(arrayUShort.toList()), listUShort.toEnumSet())
+
+    val listInt = listOf(MessageFlagInt.Redirected, MessageFlagInt.Backlog)
+    assertEquals(EnumSet.copyOf(listInt), listInt.toEnumSet())
+    val arrayInt = arrayOf(MessageFlagInt.Redirected, MessageFlagInt.Backlog)
+    assertEquals(EnumSet.copyOf(arrayInt.toList()), listInt.toEnumSet())
+
+    val listUInt = listOf(MessageFlagUInt.Redirected, MessageFlagUInt.Backlog)
+    assertEquals(EnumSet.copyOf(listUInt), listUInt.toEnumSet())
+    val arrayUInt = arrayOf(MessageFlagUInt.Redirected, MessageFlagUInt.Backlog)
+    assertEquals(EnumSet.copyOf(arrayUInt.toList()), listUInt.toEnumSet())
+
+    val listLong = listOf(MessageFlagLong.Redirected, MessageFlagLong.Backlog)
+    assertEquals(EnumSet.copyOf(listLong), listLong.toEnumSet())
+    val arrayLong = arrayOf(MessageFlagLong.Redirected, MessageFlagLong.Backlog)
+    assertEquals(EnumSet.copyOf(arrayLong.toList()), listLong.toEnumSet())
+
+    val listULong = listOf(MessageFlagULong.Redirected, MessageFlagULong.Backlog)
+    assertEquals(EnumSet.copyOf(listULong), listULong.toEnumSet())
+    val arrayULong = arrayOf(MessageFlagULong.Redirected, MessageFlagULong.Backlog)
+    assertEquals(EnumSet.copyOf(arrayULong.toList()), listULong.toEnumSet())
+  }
+}
diff --git a/src/test/kotlin/de/justjanne/bitflags/ValidValuesTest.kt b/src/test/kotlin/de/justjanne/bitflags/ValidValuesTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..b55b9b4425831b3a55ffeec2799cb8510109cf85
--- /dev/null
+++ b/src/test/kotlin/de/justjanne/bitflags/ValidValuesTest.kt
@@ -0,0 +1,102 @@
+/*
+ * Kotlin Bitflags
+ * Copyright (c) 2021 Janne Mareike Koschinski
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public License,
+ * v. 2.0. If a copy of the MPL was not distributed with this file, You can
+ * obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package de.justjanne.bitflags
+
+import de.justjanne.bitflags.test.MessageFlagByte
+import de.justjanne.bitflags.test.MessageFlagInt
+import de.justjanne.bitflags.test.MessageFlagLong
+import de.justjanne.bitflags.test.MessageFlagShort
+import de.justjanne.bitflags.test.MessageFlagUByte
+import de.justjanne.bitflags.test.MessageFlagUInt
+import de.justjanne.bitflags.test.MessageFlagULong
+import de.justjanne.bitflags.test.MessageFlagUShort
+import org.junit.jupiter.api.Assertions.assertFalse
+import org.junit.jupiter.api.Test
+import kotlin.test.assertTrue
+
+class ValidValuesTest {
+  @Test
+  fun `contains known good values`() {
+    assertTrue(MessageFlagByte.validValues().contains(MessageFlagByte.Self))
+    assertTrue(MessageFlagByte.validValues().contains(MessageFlagByte.Highlight))
+    assertTrue(MessageFlagByte.validValues().contains(MessageFlagByte.ServerMsg))
+    assertTrue(MessageFlagByte.validValues().contains(MessageFlagByte.Redirected))
+    assertTrue(MessageFlagByte.validValues().contains(MessageFlagByte.Backlog))
+
+    assertTrue(MessageFlagUByte.validValues().contains(MessageFlagUByte.Self))
+    assertTrue(MessageFlagUByte.validValues().contains(MessageFlagUByte.Highlight))
+    assertTrue(MessageFlagUByte.validValues().contains(MessageFlagUByte.ServerMsg))
+    assertTrue(MessageFlagUByte.validValues().contains(MessageFlagUByte.Redirected))
+    assertTrue(MessageFlagUByte.validValues().contains(MessageFlagUByte.Backlog))
+
+    assertTrue(MessageFlagShort.validValues().contains(MessageFlagShort.Self))
+    assertTrue(MessageFlagShort.validValues().contains(MessageFlagShort.Highlight))
+    assertTrue(MessageFlagShort.validValues().contains(MessageFlagShort.ServerMsg))
+    assertTrue(MessageFlagShort.validValues().contains(MessageFlagShort.Redirected))
+    assertTrue(MessageFlagShort.validValues().contains(MessageFlagShort.Backlog))
+
+    assertTrue(MessageFlagUShort.validValues().contains(MessageFlagUShort.Self))
+    assertTrue(MessageFlagUShort.validValues().contains(MessageFlagUShort.Highlight))
+    assertTrue(MessageFlagUShort.validValues().contains(MessageFlagUShort.ServerMsg))
+    assertTrue(MessageFlagUShort.validValues().contains(MessageFlagUShort.Redirected))
+    assertTrue(MessageFlagUShort.validValues().contains(MessageFlagUShort.Backlog))
+
+    assertTrue(MessageFlagInt.validValues().contains(MessageFlagInt.Self))
+    assertTrue(MessageFlagInt.validValues().contains(MessageFlagInt.Highlight))
+    assertTrue(MessageFlagInt.validValues().contains(MessageFlagInt.ServerMsg))
+    assertTrue(MessageFlagInt.validValues().contains(MessageFlagInt.Redirected))
+    assertTrue(MessageFlagInt.validValues().contains(MessageFlagInt.Backlog))
+
+    assertTrue(MessageFlagUInt.validValues().contains(MessageFlagUInt.Self))
+    assertTrue(MessageFlagUInt.validValues().contains(MessageFlagUInt.Highlight))
+    assertTrue(MessageFlagUInt.validValues().contains(MessageFlagUInt.ServerMsg))
+    assertTrue(MessageFlagUInt.validValues().contains(MessageFlagUInt.Redirected))
+    assertTrue(MessageFlagUInt.validValues().contains(MessageFlagUInt.Backlog))
+
+    assertTrue(MessageFlagLong.validValues().contains(MessageFlagLong.Self))
+    assertTrue(MessageFlagLong.validValues().contains(MessageFlagLong.Highlight))
+    assertTrue(MessageFlagLong.validValues().contains(MessageFlagLong.ServerMsg))
+    assertTrue(MessageFlagLong.validValues().contains(MessageFlagLong.Redirected))
+    assertTrue(MessageFlagLong.validValues().contains(MessageFlagLong.Backlog))
+
+    assertTrue(MessageFlagULong.validValues().contains(MessageFlagULong.Self))
+    assertTrue(MessageFlagULong.validValues().contains(MessageFlagULong.Highlight))
+    assertTrue(MessageFlagULong.validValues().contains(MessageFlagULong.ServerMsg))
+    assertTrue(MessageFlagULong.validValues().contains(MessageFlagULong.Redirected))
+    assertTrue(MessageFlagULong.validValues().contains(MessageFlagULong.Backlog))
+  }
+
+  @Test
+  fun `does not contain known bad values`() {
+    assertFalse(MessageFlagByte.validValues().contains(MessageFlagByte.Unknown))
+    assertFalse(MessageFlagUByte.validValues().contains(MessageFlagUByte.Unknown))
+
+    assertFalse(MessageFlagByte.validValues().contains(MessageFlagByte.Unknown))
+    assertFalse(MessageFlagUByte.validValues().contains(MessageFlagUByte.Unknown))
+
+    assertFalse(MessageFlagShort.validValues().contains(MessageFlagShort.Unknown))
+    assertFalse(MessageFlagUShort.validValues().contains(MessageFlagUShort.Unknown))
+
+    assertFalse(MessageFlagShort.validValues().contains(MessageFlagShort.Unknown))
+    assertFalse(MessageFlagUShort.validValues().contains(MessageFlagUShort.Unknown))
+
+    assertFalse(MessageFlagInt.validValues().contains(MessageFlagInt.Unknown))
+    assertFalse(MessageFlagUInt.validValues().contains(MessageFlagUInt.Unknown))
+
+    assertFalse(MessageFlagInt.validValues().contains(MessageFlagInt.Unknown))
+    assertFalse(MessageFlagUInt.validValues().contains(MessageFlagUInt.Unknown))
+
+    assertFalse(MessageFlagLong.validValues().contains(MessageFlagLong.Unknown))
+    assertFalse(MessageFlagULong.validValues().contains(MessageFlagULong.Unknown))
+
+    assertFalse(MessageFlagLong.validValues().contains(MessageFlagLong.Unknown))
+    assertFalse(MessageFlagULong.validValues().contains(MessageFlagULong.Unknown))
+  }
+}
diff --git a/src/test/kotlin/de/justjanne/bitflags/test/MessageFlagByte.kt b/src/test/kotlin/de/justjanne/bitflags/test/MessageFlagByte.kt
new file mode 100644
index 0000000000000000000000000000000000000000..988d225b5c435922fe8d67c016aa1512736f131c
--- /dev/null
+++ b/src/test/kotlin/de/justjanne/bitflags/test/MessageFlagByte.kt
@@ -0,0 +1,29 @@
+/*
+ * Kotlin Bitflags
+ * Copyright (c) 2021 Janne Mareike Koschinski
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public License,
+ * v. 2.0. If a copy of the MPL was not distributed with this file, You can
+ * obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package de.justjanne.bitflags.test
+
+import de.justjanne.bitflags.Flag
+import de.justjanne.bitflags.Flags
+import de.justjanne.bitflags.toEnumSet
+
+enum class MessageFlagByte(
+  override val value: Byte,
+) : Flag<Byte> {
+  Unknown(0x00),
+  Self(0x01),
+  Highlight(0x02),
+  Redirected(0x04),
+  ServerMsg(0x08),
+  Backlog(0x10);
+
+  companion object : Flags<Byte, MessageFlagByte> {
+    override val all: Set<MessageFlagByte> = values().toEnumSet()
+  }
+}
diff --git a/src/test/kotlin/de/justjanne/bitflags/test/MessageFlagInt.kt b/src/test/kotlin/de/justjanne/bitflags/test/MessageFlagInt.kt
new file mode 100644
index 0000000000000000000000000000000000000000..b25ad71fe129ba8c7708a54dfbb7cd67761542ec
--- /dev/null
+++ b/src/test/kotlin/de/justjanne/bitflags/test/MessageFlagInt.kt
@@ -0,0 +1,29 @@
+/*
+ * Kotlin Bitflags
+ * Copyright (c) 2021 Janne Mareike Koschinski
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public License,
+ * v. 2.0. If a copy of the MPL was not distributed with this file, You can
+ * obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package de.justjanne.bitflags.test
+
+import de.justjanne.bitflags.Flag
+import de.justjanne.bitflags.Flags
+import de.justjanne.bitflags.toEnumSet
+
+enum class MessageFlagInt(
+  override val value: Int,
+) : Flag<Int> {
+  Unknown(0x00),
+  Self(0x01),
+  Highlight(0x02),
+  Redirected(0x04),
+  ServerMsg(0x08),
+  Backlog(0x10);
+
+  companion object : Flags<Int, MessageFlagInt> {
+    override val all: Set<MessageFlagInt> = values().toEnumSet()
+  }
+}
diff --git a/src/test/kotlin/de/justjanne/bitflags/test/MessageFlagLong.kt b/src/test/kotlin/de/justjanne/bitflags/test/MessageFlagLong.kt
new file mode 100644
index 0000000000000000000000000000000000000000..1d9a9b13913444ab0d0fcec656810569800b4f8e
--- /dev/null
+++ b/src/test/kotlin/de/justjanne/bitflags/test/MessageFlagLong.kt
@@ -0,0 +1,29 @@
+/*
+ * Kotlin Bitflags
+ * Copyright (c) 2021 Janne Mareike Koschinski
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public License,
+ * v. 2.0. If a copy of the MPL was not distributed with this file, You can
+ * obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package de.justjanne.bitflags.test
+
+import de.justjanne.bitflags.Flag
+import de.justjanne.bitflags.Flags
+import de.justjanne.bitflags.toEnumSet
+
+enum class MessageFlagLong(
+  override val value: Long,
+) : Flag<Long> {
+  Unknown(0x00),
+  Self(0x01),
+  Highlight(0x02),
+  Redirected(0x04),
+  ServerMsg(0x08),
+  Backlog(0x10);
+
+  companion object : Flags<Long, MessageFlagLong> {
+    override val all: Set<MessageFlagLong> = values().toEnumSet()
+  }
+}
diff --git a/src/test/kotlin/de/justjanne/bitflags/test/MessageFlagShort.kt b/src/test/kotlin/de/justjanne/bitflags/test/MessageFlagShort.kt
new file mode 100644
index 0000000000000000000000000000000000000000..09a9c2978d15a686a4aab6bfda1087b8c5a2dbeb
--- /dev/null
+++ b/src/test/kotlin/de/justjanne/bitflags/test/MessageFlagShort.kt
@@ -0,0 +1,29 @@
+/*
+ * Kotlin Bitflags
+ * Copyright (c) 2021 Janne Mareike Koschinski
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public License,
+ * v. 2.0. If a copy of the MPL was not distributed with this file, You can
+ * obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package de.justjanne.bitflags.test
+
+import de.justjanne.bitflags.Flag
+import de.justjanne.bitflags.Flags
+import de.justjanne.bitflags.toEnumSet
+
+enum class MessageFlagShort(
+  override val value: Short,
+) : Flag<Short> {
+  Unknown(0x00),
+  Self(0x01),
+  Highlight(0x02),
+  Redirected(0x04),
+  ServerMsg(0x08),
+  Backlog(0x10);
+
+  companion object : Flags<Short, MessageFlagShort> {
+    override val all: Set<MessageFlagShort> = values().toEnumSet()
+  }
+}
diff --git a/src/test/kotlin/de/justjanne/bitflags/test/MessageFlagUByte.kt b/src/test/kotlin/de/justjanne/bitflags/test/MessageFlagUByte.kt
new file mode 100644
index 0000000000000000000000000000000000000000..36c34b0ca1d3d1f2e747d00b571ee6a72a0608bc
--- /dev/null
+++ b/src/test/kotlin/de/justjanne/bitflags/test/MessageFlagUByte.kt
@@ -0,0 +1,29 @@
+/*
+ * Kotlin Bitflags
+ * Copyright (c) 2021 Janne Mareike Koschinski
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public License,
+ * v. 2.0. If a copy of the MPL was not distributed with this file, You can
+ * obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package de.justjanne.bitflags.test
+
+import de.justjanne.bitflags.Flag
+import de.justjanne.bitflags.Flags
+import de.justjanne.bitflags.toEnumSet
+
+enum class MessageFlagUByte(
+  override val value: UByte,
+) : Flag<UByte> {
+  Unknown(0x00u),
+  Self(0x01u),
+  Highlight(0x02u),
+  Redirected(0x04u),
+  ServerMsg(0x08u),
+  Backlog(0x10u);
+
+  companion object : Flags<UByte, MessageFlagUByte> {
+    override val all: Set<MessageFlagUByte> = values().toEnumSet()
+  }
+}
diff --git a/src/test/kotlin/de/justjanne/bitflags/test/MessageFlagUInt.kt b/src/test/kotlin/de/justjanne/bitflags/test/MessageFlagUInt.kt
new file mode 100644
index 0000000000000000000000000000000000000000..f4a10615fb371a27c7cea4e80dfef14e58eddb0d
--- /dev/null
+++ b/src/test/kotlin/de/justjanne/bitflags/test/MessageFlagUInt.kt
@@ -0,0 +1,29 @@
+/*
+ * Kotlin Bitflags
+ * Copyright (c) 2021 Janne Mareike Koschinski
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public License,
+ * v. 2.0. If a copy of the MPL was not distributed with this file, You can
+ * obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package de.justjanne.bitflags.test
+
+import de.justjanne.bitflags.Flag
+import de.justjanne.bitflags.Flags
+import de.justjanne.bitflags.toEnumSet
+
+enum class MessageFlagUInt(
+  override val value: UInt,
+) : Flag<UInt> {
+  Unknown(0x00u),
+  Self(0x01u),
+  Highlight(0x02u),
+  Redirected(0x04u),
+  ServerMsg(0x08u),
+  Backlog(0x10u);
+
+  companion object : Flags<UInt, MessageFlagUInt> {
+    override val all: Set<MessageFlagUInt> = values().toEnumSet()
+  }
+}
diff --git a/src/test/kotlin/de/justjanne/bitflags/test/MessageFlagULong.kt b/src/test/kotlin/de/justjanne/bitflags/test/MessageFlagULong.kt
new file mode 100644
index 0000000000000000000000000000000000000000..4c27716d80d8f689cea71264f6e662c589b0871a
--- /dev/null
+++ b/src/test/kotlin/de/justjanne/bitflags/test/MessageFlagULong.kt
@@ -0,0 +1,29 @@
+/*
+ * Kotlin Bitflags
+ * Copyright (c) 2021 Janne Mareike Koschinski
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public License,
+ * v. 2.0. If a copy of the MPL was not distributed with this file, You can
+ * obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package de.justjanne.bitflags.test
+
+import de.justjanne.bitflags.Flag
+import de.justjanne.bitflags.Flags
+import de.justjanne.bitflags.toEnumSet
+
+enum class MessageFlagULong(
+  override val value: ULong,
+) : Flag<ULong> {
+  Unknown(0x00u),
+  Self(0x01u),
+  Highlight(0x02u),
+  Redirected(0x04u),
+  ServerMsg(0x08u),
+  Backlog(0x10u);
+
+  companion object : Flags<ULong, MessageFlagULong> {
+    override val all: Set<MessageFlagULong> = values().toEnumSet()
+  }
+}
diff --git a/src/test/kotlin/de/justjanne/bitflags/test/MessageFlagUShort.kt b/src/test/kotlin/de/justjanne/bitflags/test/MessageFlagUShort.kt
new file mode 100644
index 0000000000000000000000000000000000000000..bdca2b0b7000f65eee371693419a20ac276bcb64
--- /dev/null
+++ b/src/test/kotlin/de/justjanne/bitflags/test/MessageFlagUShort.kt
@@ -0,0 +1,29 @@
+/*
+ * Kotlin Bitflags
+ * Copyright (c) 2021 Janne Mareike Koschinski
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public License,
+ * v. 2.0. If a copy of the MPL was not distributed with this file, You can
+ * obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package de.justjanne.bitflags.test
+
+import de.justjanne.bitflags.Flag
+import de.justjanne.bitflags.Flags
+import de.justjanne.bitflags.toEnumSet
+
+enum class MessageFlagUShort(
+  override val value: UShort,
+) : Flag<UShort> {
+  Unknown(0x00u),
+  Self(0x01u),
+  Highlight(0x02u),
+  Redirected(0x04u),
+  ServerMsg(0x08u),
+  Backlog(0x10u);
+
+  companion object : Flags<UShort, MessageFlagUShort> {
+    override val all: Set<MessageFlagUShort> = values().toEnumSet()
+  }
+}