Implement tests

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"

src/test/kotlin/de/justjanne/bitflags/NoneTest.kt

+/*
+ * 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))
+  }
+}

src/test/kotlin/de/justjanne/bitflags/ToBitsTest.kt

+/*
+ * 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())
+  }
+}

src/test/kotlin/de/justjanne/bitflags/ToEnumSetTest.kt

+/*
+ * 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())
+  }
+}

src/test/kotlin/de/justjanne/bitflags/ValidValuesTest.kt

+/*
+ * 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))
+  }
+}

src/test/kotlin/de/justjanne/bitflags/test/MessageFlagByte.kt

+/*
+ * 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()
+  }
+}

src/test/kotlin/de/justjanne/bitflags/test/MessageFlagInt.kt

+/*
+ * 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()
+  }
+}

src/test/kotlin/de/justjanne/bitflags/test/MessageFlagLong.kt

+/*
+ * 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()
+  }
+}

src/test/kotlin/de/justjanne/bitflags/test/MessageFlagShort.kt

+/*
+ * 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()
+  }
+}

src/test/kotlin/de/justjanne/bitflags/test/MessageFlagUByte.kt

+/*
+ * 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()
+  }
+}

src/test/kotlin/de/justjanne/bitflags/test/MessageFlagUInt.kt

+/*
+ * 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()
+  }
+}

src/test/kotlin/de/justjanne/bitflags/test/MessageFlagULong.kt

+/*
+ * 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()
+  }
+}

src/test/kotlin/de/justjanne/bitflags/test/MessageFlagUShort.kt

+/*
+ * 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()
+  }
+}