Sulkta-OSS/element-x-ada
3
0
Fork 0
Code Issues 1 Pull requests 9 Projects Releases Packages Wiki Activity Actions

Update dependency org.matrix.rustcomponents:sdk-android to v25.9.25 (#5412)

Browse source 
* Update dependency org.matrix.rustcomponents:sdk-android to v25.9.25

* Adapt to SDK changes:

`MessageLikeEventType` is now a sealed interface and has a new `data class Other(val v1: String)` case.

---------

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
Co-authored-by: Jorge Martín <jorgem@element.io>
This commit is contained in:
renovate[bot] 2025-09-25 14:33:15 +00:00 • committed by GitHub
parent 0b4fef3c03
commit 644c8284e4
8 changed files with 133 additions and 125 deletions
Download patch file Download diff file Expand all files Collapse all files

4
features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/MessagesPresenter.kt
View file

@ -282,8 +282,8 @@ class MessagesPresenter(
} }
return produceState(UserEventPermissions.DEFAULT, key1 = key) { return produceState(UserEventPermissions.DEFAULT, key1 = key) {
value = UserEventPermissions( value = UserEventPermissions(
canSendMessage = room.canSendMessage(type = MessageEventType.ROOM_MESSAGE).getOrElse { true }, canSendMessage = room.canSendMessage(type = MessageEventType.RoomMessage).getOrElse { true },
canSendReaction = room.canSendMessage(type = MessageEventType.REACTION).getOrElse { true }, canSendReaction = room.canSendMessage(type = MessageEventType.Reaction).getOrElse { true },
canRedactOwn = room.canRedactOwn().getOrElse { false }, canRedactOwn = room.canRedactOwn().getOrElse { false },
canRedactOther = room.canRedactOther().getOrElse { false }, canRedactOther = room.canRedactOther().getOrElse { false },
canPinUnpin = room.canPinUnpin().getOrElse { false }, canPinUnpin = room.canPinUnpin().getOrElse { false },

4
features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/TimelinePresenter.kt
View file

@ -117,8 +117,8 @@ class TimelinePresenter(
val syncUpdateFlow = room.syncUpdateFlow.collectAsState() val syncUpdateFlow = room.syncUpdateFlow.collectAsState()
val userHasPermissionToSendMessage by room.canSendMessageAsState(type = MessageEventType.ROOM_MESSAGE, updateKey = syncUpdateFlow.value) val userHasPermissionToSendMessage by room.canSendMessageAsState(type = MessageEventType.RoomMessage, updateKey = syncUpdateFlow.value)
val userHasPermissionToSendReaction by room.canSendMessageAsState(type = MessageEventType.REACTION, updateKey = syncUpdateFlow.value) val userHasPermissionToSendReaction by room.canSendMessageAsState(type = MessageEventType.Reaction, updateKey = syncUpdateFlow.value)
val prevMostRecentItemId = rememberSaveable { mutableStateOf<UniqueId?>(null) } val prevMostRecentItemId = rememberSaveable { mutableStateOf<UniqueId?>(null) }

8
features/messages/impl/src/test/kotlin/io/element/android/features/messages/impl/MessagesPresenterTest.kt
View file

@ -794,8 +794,8 @@ class MessagesPresenterTest {
canUserPinUnpinResult = { Result.success(true) }, canUserPinUnpinResult = { Result.success(true) },
canUserSendMessageResult = { _, messageEventType -> canUserSendMessageResult = { _, messageEventType ->
when (messageEventType) { when (messageEventType) {
MessageEventType.ROOM_MESSAGE -> Result.success(true) MessageEventType.RoomMessage -> Result.success(true)
MessageEventType.REACTION -> Result.success(true) MessageEventType.Reaction -> Result.success(true)
else -> lambdaError() else -> lambdaError()
} }
}, },
@ -820,8 +820,8 @@ class MessagesPresenterTest {
canUserPinUnpinResult = { Result.success(true) }, canUserPinUnpinResult = { Result.success(true) },
canUserSendMessageResult = { _, messageEventType -> canUserSendMessageResult = { _, messageEventType ->
when (messageEventType) { when (messageEventType) {
MessageEventType.ROOM_MESSAGE -> Result.success(false) MessageEventType.RoomMessage -> Result.success(false)
MessageEventType.REACTION -> Result.success(false) MessageEventType.Reaction -> Result.success(false)
else -> lambdaError() else -> lambdaError()
} }
}, },

2
gradle/libs.versions.toml
View file

@ -166,7 +166,7 @@ test_detekt_test = { module = "io.gitlab.arturbosch.detekt:detekt-test", version
# https://github.com/matrix-org/matrix-rust-components-kotlin/commits/main/sdk/sdk-android/src/main/kotlin/org/matrix/rustcomponents/sdk/matrix_sdk_ffi.kt # https://github.com/matrix-org/matrix-rust-components-kotlin/commits/main/sdk/sdk-android/src/main/kotlin/org/matrix/rustcomponents/sdk/matrix_sdk_ffi.kt
# All new features should not be implemented in the pull request that upgrades the version, developers should # All new features should not be implemented in the pull request that upgrades the version, developers should
# only fix API breaks and may add some TODOs. # only fix API breaks and may add some TODOs.
matrix_sdk = "org.matrix.rustcomponents:sdk-android:25.9.23" matrix_sdk = "org.matrix.rustcomponents:sdk-android:25.9.25"
# Others # Others
coil = { module = "io.coil-kt.coil3:coil", version.ref = "coil" } coil = { module = "io.coil-kt.coil3:coil", version.ref = "coil" }

52
libraries/matrix/api/src/main/kotlin/io/element/android/libraries/matrix/api/room/MessageEventType.kt
View file

@ -7,28 +7,32 @@
package io.element.android.libraries.matrix.api.room package io.element.android.libraries.matrix.api.room
enum class MessageEventType { import androidx.compose.runtime.Immutable
CALL_ANSWER,
CALL_INVITE, @Immutable
CALL_HANGUP, sealed interface MessageEventType {
CALL_CANDIDATES, data object CallAnswer : MessageEventType
RTC_NOTIFICATION, data object CallInvite : MessageEventType
KEY_VERIFICATION_READY, data object CallHangup : MessageEventType
KEY_VERIFICATION_START, data object CallCandidates : MessageEventType
KEY_VERIFICATION_CANCEL, data object RtcNotification : MessageEventType
KEY_VERIFICATION_ACCEPT, data object KeyVerificationReady : MessageEventType
KEY_VERIFICATION_KEY, data object KeyVerificationStart : MessageEventType
KEY_VERIFICATION_MAC, data object KeyVerificationCancel : MessageEventType
KEY_VERIFICATION_DONE, data object KeyVerificationAccept : MessageEventType
REACTION, data object KeyVerificationKey : MessageEventType
ROOM_ENCRYPTED, data object KeyVerificationMac : MessageEventType
ROOM_MESSAGE, data object KeyVerificationDone : MessageEventType
ROOM_REDACTION, data object Reaction : MessageEventType
STICKER, data object RoomEncrypted : MessageEventType
POLL_END, data object RoomMessage : MessageEventType
POLL_RESPONSE, data object RoomRedaction : MessageEventType
POLL_START, data object Sticker : MessageEventType
UNSTABLE_POLL_END, data object PollEnd : MessageEventType
UNSTABLE_POLL_RESPONSE, data object PollResponse : MessageEventType
UNSTABLE_POLL_START, data object PollStart : MessageEventType
data object UnstablePollEnd : MessageEventType
data object UnstablePollResponse : MessageEventType
data object UnstablePollStart : MessageEventType
data class Other(val type: String) : MessageEventType
} }

94
libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/room/MessageEventType.kt
View file

@ -11,53 +11,55 @@ import io.element.android.libraries.matrix.api.room.MessageEventType
import org.matrix.rustcomponents.sdk.MessageLikeEventType import org.matrix.rustcomponents.sdk.MessageLikeEventType
fun MessageEventType.map(): MessageLikeEventType = when (this) { fun MessageEventType.map(): MessageLikeEventType = when (this) {
MessageEventType.CALL_ANSWER -> MessageLikeEventType.CALL_ANSWER MessageEventType.CallAnswer -> MessageLikeEventType.CallAnswer
MessageEventType.CALL_INVITE -> MessageLikeEventType.CALL_INVITE MessageEventType.CallInvite -> MessageLikeEventType.CallInvite
MessageEventType.CALL_HANGUP -> MessageLikeEventType.CALL_HANGUP MessageEventType.CallHangup -> MessageLikeEventType.CallHangup
MessageEventType.CALL_CANDIDATES -> MessageLikeEventType.CALL_CANDIDATES MessageEventType.CallCandidates -> MessageLikeEventType.CallCandidates
MessageEventType.RTC_NOTIFICATION -> MessageLikeEventType.RTC_NOTIFICATION MessageEventType.RtcNotification -> MessageLikeEventType.RtcNotification
MessageEventType.KEY_VERIFICATION_READY -> MessageLikeEventType.KEY_VERIFICATION_READY MessageEventType.KeyVerificationReady -> MessageLikeEventType.KeyVerificationReady
MessageEventType.KEY_VERIFICATION_START -> MessageLikeEventType.KEY_VERIFICATION_START MessageEventType.KeyVerificationStart -> MessageLikeEventType.KeyVerificationStart
MessageEventType.KEY_VERIFICATION_CANCEL -> MessageLikeEventType.KEY_VERIFICATION_CANCEL MessageEventType.KeyVerificationCancel -> MessageLikeEventType.KeyVerificationCancel
MessageEventType.KEY_VERIFICATION_ACCEPT -> MessageLikeEventType.KEY_VERIFICATION_ACCEPT MessageEventType.KeyVerificationAccept -> MessageLikeEventType.KeyVerificationAccept
MessageEventType.KEY_VERIFICATION_KEY -> MessageLikeEventType.KEY_VERIFICATION_KEY MessageEventType.KeyVerificationKey -> MessageLikeEventType.KeyVerificationKey
MessageEventType.KEY_VERIFICATION_MAC -> MessageLikeEventType.KEY_VERIFICATION_MAC MessageEventType.KeyVerificationMac -> MessageLikeEventType.KeyVerificationMac
MessageEventType.KEY_VERIFICATION_DONE -> MessageLikeEventType.KEY_VERIFICATION_DONE MessageEventType.KeyVerificationDone -> MessageLikeEventType.KeyVerificationDone
MessageEventType.REACTION -> MessageLikeEventType.REACTION MessageEventType.Reaction -> MessageLikeEventType.Reaction
MessageEventType.ROOM_ENCRYPTED -> MessageLikeEventType.ROOM_ENCRYPTED MessageEventType.RoomEncrypted -> MessageLikeEventType.RoomEncrypted
MessageEventType.ROOM_MESSAGE -> MessageLikeEventType.ROOM_MESSAGE MessageEventType.RoomMessage -> MessageLikeEventType.RoomMessage
MessageEventType.ROOM_REDACTION -> MessageLikeEventType.ROOM_REDACTION MessageEventType.RoomRedaction -> MessageLikeEventType.RoomRedaction
MessageEventType.STICKER -> MessageLikeEventType.STICKER MessageEventType.Sticker -> MessageLikeEventType.Sticker
MessageEventType.POLL_END -> MessageLikeEventType.POLL_END MessageEventType.PollEnd -> MessageLikeEventType.PollEnd
MessageEventType.POLL_RESPONSE -> MessageLikeEventType.POLL_RESPONSE MessageEventType.PollResponse -> MessageLikeEventType.PollResponse
MessageEventType.POLL_START -> MessageLikeEventType.POLL_START MessageEventType.PollStart -> MessageLikeEventType.PollStart
MessageEventType.UNSTABLE_POLL_END -> MessageLikeEventType.UNSTABLE_POLL_END MessageEventType.UnstablePollEnd -> MessageLikeEventType.UnstablePollEnd
MessageEventType.UNSTABLE_POLL_RESPONSE -> MessageLikeEventType.UNSTABLE_POLL_RESPONSE MessageEventType.UnstablePollResponse -> MessageLikeEventType.UnstablePollResponse
MessageEventType.UNSTABLE_POLL_START -> MessageLikeEventType.UNSTABLE_POLL_START MessageEventType.UnstablePollStart -> MessageLikeEventType.UnstablePollStart
is MessageEventType.Other -> MessageLikeEventType.Other(type)
} }
fun MessageLikeEventType.map(): MessageEventType = when (this) { fun MessageLikeEventType.map(): MessageEventType = when (this) {
MessageLikeEventType.CALL_ANSWER -> MessageEventType.CALL_ANSWER MessageLikeEventType.CallAnswer -> MessageEventType.CallAnswer
MessageLikeEventType.CALL_INVITE -> MessageEventType.CALL_INVITE MessageLikeEventType.CallInvite -> MessageEventType.CallInvite
MessageLikeEventType.CALL_HANGUP -> MessageEventType.CALL_HANGUP MessageLikeEventType.CallHangup -> MessageEventType.CallHangup
MessageLikeEventType.CALL_CANDIDATES -> MessageEventType.CALL_CANDIDATES MessageLikeEventType.CallCandidates -> MessageEventType.CallCandidates
MessageLikeEventType.RTC_NOTIFICATION -> MessageEventType.RTC_NOTIFICATION MessageLikeEventType.RtcNotification -> MessageEventType.RtcNotification
MessageLikeEventType.KEY_VERIFICATION_READY -> MessageEventType.KEY_VERIFICATION_READY MessageLikeEventType.KeyVerificationReady -> MessageEventType.KeyVerificationReady
MessageLikeEventType.KEY_VERIFICATION_START -> MessageEventType.KEY_VERIFICATION_START MessageLikeEventType.KeyVerificationStart -> MessageEventType.KeyVerificationStart
MessageLikeEventType.KEY_VERIFICATION_CANCEL -> MessageEventType.KEY_VERIFICATION_CANCEL MessageLikeEventType.KeyVerificationCancel -> MessageEventType.KeyVerificationCancel
MessageLikeEventType.KEY_VERIFICATION_ACCEPT -> MessageEventType.KEY_VERIFICATION_ACCEPT MessageLikeEventType.KeyVerificationAccept -> MessageEventType.KeyVerificationAccept
MessageLikeEventType.KEY_VERIFICATION_KEY -> MessageEventType.KEY_VERIFICATION_KEY MessageLikeEventType.KeyVerificationKey -> MessageEventType.KeyVerificationKey
MessageLikeEventType.KEY_VERIFICATION_MAC -> MessageEventType.KEY_VERIFICATION_MAC MessageLikeEventType.KeyVerificationMac -> MessageEventType.KeyVerificationMac
MessageLikeEventType.KEY_VERIFICATION_DONE -> MessageEventType.KEY_VERIFICATION_DONE MessageLikeEventType.KeyVerificationDone -> MessageEventType.KeyVerificationDone
MessageLikeEventType.REACTION -> MessageEventType.REACTION MessageLikeEventType.Reaction -> MessageEventType.Reaction
MessageLikeEventType.ROOM_ENCRYPTED -> MessageEventType.ROOM_ENCRYPTED MessageLikeEventType.RoomEncrypted -> MessageEventType.RoomEncrypted
MessageLikeEventType.ROOM_MESSAGE -> MessageEventType.ROOM_MESSAGE MessageLikeEventType.RoomMessage -> MessageEventType.RoomMessage
MessageLikeEventType.ROOM_REDACTION -> MessageEventType.ROOM_REDACTION MessageLikeEventType.RoomRedaction -> MessageEventType.RoomRedaction
MessageLikeEventType.STICKER -> MessageEventType.STICKER MessageLikeEventType.Sticker -> MessageEventType.Sticker
MessageLikeEventType.POLL_END -> MessageEventType.POLL_END MessageLikeEventType.PollEnd -> MessageEventType.PollEnd
MessageLikeEventType.POLL_RESPONSE -> MessageEventType.POLL_RESPONSE MessageLikeEventType.PollResponse -> MessageEventType.PollResponse
MessageLikeEventType.POLL_START -> MessageEventType.POLL_START MessageLikeEventType.PollStart -> MessageEventType.PollStart
MessageLikeEventType.UNSTABLE_POLL_END -> MessageEventType.UNSTABLE_POLL_END MessageLikeEventType.UnstablePollEnd -> MessageEventType.UnstablePollEnd
MessageLikeEventType.UNSTABLE_POLL_RESPONSE -> MessageEventType.UNSTABLE_POLL_RESPONSE MessageLikeEventType.UnstablePollResponse -> MessageEventType.UnstablePollResponse
MessageLikeEventType.UNSTABLE_POLL_START -> MessageEventType.UNSTABLE_POLL_START MessageLikeEventType.UnstablePollStart -> MessageEventType.UnstablePollStart
is MessageLikeEventType.Other -> MessageEventType.Other(v1)
} }

2
libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/timeline/item/event/TimelineEventContentMapper.kt
View file

@ -27,6 +27,7 @@ import io.element.android.libraries.matrix.api.timeline.item.event.RoomMembershi
import io.element.android.libraries.matrix.api.timeline.item.event.StateContent import io.element.android.libraries.matrix.api.timeline.item.event.StateContent
import io.element.android.libraries.matrix.api.timeline.item.event.StickerContent import io.element.android.libraries.matrix.api.timeline.item.event.StickerContent
import io.element.android.libraries.matrix.api.timeline.item.event.UnableToDecryptContent import io.element.android.libraries.matrix.api.timeline.item.event.UnableToDecryptContent
import io.element.android.libraries.matrix.api.timeline.item.event.UnknownContent
import io.element.android.libraries.matrix.api.timeline.item.event.UtdCause import io.element.android.libraries.matrix.api.timeline.item.event.UtdCause
import io.element.android.libraries.matrix.impl.media.map import io.element.android.libraries.matrix.impl.media.map
import io.element.android.libraries.matrix.impl.poll.map import io.element.android.libraries.matrix.impl.poll.map
@ -126,6 +127,7 @@ class TimelineEventContentMapper(
source = kind.source.map(), source = kind.source.map(),
) )
} }
is MsgLikeKind.Other -> UnknownContent
} }
} }
is TimelineItemContent.ProfileChange -> { is TimelineItemContent.ProfileChange -> {

92
libraries/matrix/impl/src/test/kotlin/io/element/android/libraries/matrix/impl/room/MessageEventTypeKtTest.kt
View file

@ -15,55 +15,55 @@ import org.matrix.rustcomponents.sdk.MessageLikeEventType
class MessageEventTypeKtTest { class MessageEventTypeKtTest {
@Test @Test
fun `map Rust type should result to correct Kotlin type`() { fun `map Rust type should result to correct Kotlin type`() {
assertThat(MessageLikeEventType.CALL_ANSWER.map()).isEqualTo(MessageEventType.CALL_ANSWER) assertThat(MessageLikeEventType.CallAnswer.map()).isEqualTo(MessageEventType.CallAnswer)
assertThat(MessageLikeEventType.CALL_INVITE.map()).isEqualTo(MessageEventType.CALL_INVITE) assertThat(MessageLikeEventType.CallInvite.map()).isEqualTo(MessageEventType.CallInvite)
assertThat(MessageLikeEventType.CALL_HANGUP.map()).isEqualTo(MessageEventType.CALL_HANGUP) assertThat(MessageLikeEventType.CallHangup.map()).isEqualTo(MessageEventType.CallHangup)
assertThat(MessageLikeEventType.CALL_CANDIDATES.map()).isEqualTo(MessageEventType.CALL_CANDIDATES) assertThat(MessageLikeEventType.CallCandidates.map()).isEqualTo(MessageEventType.CallCandidates)
assertThat(MessageLikeEventType.RTC_NOTIFICATION.map()).isEqualTo(MessageEventType.RTC_NOTIFICATION) assertThat(MessageLikeEventType.RtcNotification.map()).isEqualTo(MessageEventType.RtcNotification)
assertThat(MessageLikeEventType.KEY_VERIFICATION_READY.map()).isEqualTo(MessageEventType.KEY_VERIFICATION_READY) assertThat(MessageLikeEventType.KeyVerificationReady.map()).isEqualTo(MessageEventType.KeyVerificationReady)
assertThat(MessageLikeEventType.KEY_VERIFICATION_START.map()).isEqualTo(MessageEventType.KEY_VERIFICATION_START) assertThat(MessageLikeEventType.KeyVerificationStart.map()).isEqualTo(MessageEventType.KeyVerificationStart)
assertThat(MessageLikeEventType.KEY_VERIFICATION_CANCEL.map()).isEqualTo(MessageEventType.KEY_VERIFICATION_CANCEL) assertThat(MessageLikeEventType.KeyVerificationCancel.map()).isEqualTo(MessageEventType.KeyVerificationCancel)
assertThat(MessageLikeEventType.KEY_VERIFICATION_ACCEPT.map()).isEqualTo(MessageEventType.KEY_VERIFICATION_ACCEPT) assertThat(MessageLikeEventType.KeyVerificationAccept.map()).isEqualTo(MessageEventType.KeyVerificationAccept)
assertThat(MessageLikeEventType.KEY_VERIFICATION_KEY.map()).isEqualTo(MessageEventType.KEY_VERIFICATION_KEY) assertThat(MessageLikeEventType.KeyVerificationKey.map()).isEqualTo(MessageEventType.KeyVerificationKey)
assertThat(MessageLikeEventType.KEY_VERIFICATION_MAC.map()).isEqualTo(MessageEventType.KEY_VERIFICATION_MAC) assertThat(MessageLikeEventType.KeyVerificationMac.map()).isEqualTo(MessageEventType.KeyVerificationMac)
assertThat(MessageLikeEventType.KEY_VERIFICATION_DONE.map()).isEqualTo(MessageEventType.KEY_VERIFICATION_DONE) assertThat(MessageLikeEventType.KeyVerificationDone.map()).isEqualTo(MessageEventType.KeyVerificationDone)
assertThat(MessageLikeEventType.REACTION.map()).isEqualTo(MessageEventType.REACTION) assertThat(MessageLikeEventType.Reaction.map()).isEqualTo(MessageEventType.Reaction)
assertThat(MessageLikeEventType.ROOM_ENCRYPTED.map()).isEqualTo(MessageEventType.ROOM_ENCRYPTED) assertThat(MessageLikeEventType.RoomEncrypted.map()).isEqualTo(MessageEventType.RoomEncrypted)
assertThat(MessageLikeEventType.ROOM_MESSAGE.map()).isEqualTo(MessageEventType.ROOM_MESSAGE) assertThat(MessageLikeEventType.RoomMessage.map()).isEqualTo(MessageEventType.RoomMessage)
assertThat(MessageLikeEventType.ROOM_REDACTION.map()).isEqualTo(MessageEventType.ROOM_REDACTION) assertThat(MessageLikeEventType.RoomRedaction.map()).isEqualTo(MessageEventType.RoomRedaction)
assertThat(MessageLikeEventType.STICKER.map()).isEqualTo(MessageEventType.STICKER) assertThat(MessageLikeEventType.Sticker.map()).isEqualTo(MessageEventType.Sticker)
assertThat(MessageLikeEventType.POLL_END.map()).isEqualTo(MessageEventType.POLL_END) assertThat(MessageLikeEventType.PollEnd.map()).isEqualTo(MessageEventType.PollEnd)
assertThat(MessageLikeEventType.POLL_RESPONSE.map()).isEqualTo(MessageEventType.POLL_RESPONSE) assertThat(MessageLikeEventType.PollResponse.map()).isEqualTo(MessageEventType.PollResponse)
assertThat(MessageLikeEventType.POLL_START.map()).isEqualTo(MessageEventType.POLL_START) assertThat(MessageLikeEventType.PollStart.map()).isEqualTo(MessageEventType.PollStart)
assertThat(MessageLikeEventType.UNSTABLE_POLL_END.map()).isEqualTo(MessageEventType.UNSTABLE_POLL_END) assertThat(MessageLikeEventType.UnstablePollEnd.map()).isEqualTo(MessageEventType.UnstablePollEnd)
assertThat(MessageLikeEventType.UNSTABLE_POLL_RESPONSE.map()).isEqualTo(MessageEventType.UNSTABLE_POLL_RESPONSE) assertThat(MessageLikeEventType.UnstablePollResponse.map()).isEqualTo(MessageEventType.UnstablePollResponse)
assertThat(MessageLikeEventType.UNSTABLE_POLL_START.map()).isEqualTo(MessageEventType.UNSTABLE_POLL_START) assertThat(MessageLikeEventType.UnstablePollStart.map()).isEqualTo(MessageEventType.UnstablePollStart)
} }
@Test @Test
fun `map Kotlin type should result to correct Rust type`() { fun `map Kotlin type should result to correct Rust type`() {
assertThat(MessageEventType.CALL_ANSWER.map()).isEqualTo(MessageLikeEventType.CALL_ANSWER) assertThat(MessageEventType.CallAnswer.map()).isEqualTo(MessageLikeEventType.CallAnswer)
assertThat(MessageEventType.CALL_INVITE.map()).isEqualTo(MessageLikeEventType.CALL_INVITE) assertThat(MessageEventType.CallInvite.map()).isEqualTo(MessageLikeEventType.CallInvite)
assertThat(MessageEventType.CALL_HANGUP.map()).isEqualTo(MessageLikeEventType.CALL_HANGUP) assertThat(MessageEventType.CallHangup.map()).isEqualTo(MessageLikeEventType.CallHangup)
assertThat(MessageEventType.CALL_CANDIDATES.map()).isEqualTo(MessageLikeEventType.CALL_CANDIDATES) assertThat(MessageEventType.CallCandidates.map()).isEqualTo(MessageLikeEventType.CallCandidates)
assertThat(MessageEventType.RTC_NOTIFICATION.map()).isEqualTo(MessageLikeEventType.RTC_NOTIFICATION) assertThat(MessageEventType.RtcNotification.map()).isEqualTo(MessageLikeEventType.RtcNotification)
assertThat(MessageEventType.KEY_VERIFICATION_READY.map()).isEqualTo(MessageLikeEventType.KEY_VERIFICATION_READY) assertThat(MessageEventType.KeyVerificationReady.map()).isEqualTo(MessageLikeEventType.KeyVerificationReady)
assertThat(MessageEventType.KEY_VERIFICATION_START.map()).isEqualTo(MessageLikeEventType.KEY_VERIFICATION_START) assertThat(MessageEventType.KeyVerificationStart.map()).isEqualTo(MessageLikeEventType.KeyVerificationStart)
assertThat(MessageEventType.KEY_VERIFICATION_CANCEL.map()).isEqualTo(MessageLikeEventType.KEY_VERIFICATION_CANCEL) assertThat(MessageEventType.KeyVerificationCancel.map()).isEqualTo(MessageLikeEventType.KeyVerificationCancel)
assertThat(MessageEventType.KEY_VERIFICATION_ACCEPT.map()).isEqualTo(MessageLikeEventType.KEY_VERIFICATION_ACCEPT) assertThat(MessageEventType.KeyVerificationAccept.map()).isEqualTo(MessageLikeEventType.KeyVerificationAccept)
assertThat(MessageEventType.KEY_VERIFICATION_KEY.map()).isEqualTo(MessageLikeEventType.KEY_VERIFICATION_KEY) assertThat(MessageEventType.KeyVerificationKey.map()).isEqualTo(MessageLikeEventType.KeyVerificationKey)
assertThat(MessageEventType.KEY_VERIFICATION_MAC.map()).isEqualTo(MessageLikeEventType.KEY_VERIFICATION_MAC) assertThat(MessageEventType.KeyVerificationMac.map()).isEqualTo(MessageLikeEventType.KeyVerificationMac)
assertThat(MessageEventType.KEY_VERIFICATION_DONE.map()).isEqualTo(MessageLikeEventType.KEY_VERIFICATION_DONE) assertThat(MessageEventType.KeyVerificationDone.map()).isEqualTo(MessageLikeEventType.KeyVerificationDone)
assertThat(MessageEventType.REACTION.map()).isEqualTo(MessageLikeEventType.REACTION) assertThat(MessageEventType.Reaction.map()).isEqualTo(MessageLikeEventType.Reaction)
assertThat(MessageEventType.ROOM_ENCRYPTED.map()).isEqualTo(MessageLikeEventType.ROOM_ENCRYPTED) assertThat(MessageEventType.RoomEncrypted.map()).isEqualTo(MessageLikeEventType.RoomEncrypted)
assertThat(MessageEventType.ROOM_MESSAGE.map()).isEqualTo(MessageLikeEventType.ROOM_MESSAGE) assertThat(MessageEventType.RoomMessage.map()).isEqualTo(MessageLikeEventType.RoomMessage)
assertThat(MessageEventType.ROOM_REDACTION.map()).isEqualTo(MessageLikeEventType.ROOM_REDACTION) assertThat(MessageEventType.RoomRedaction.map()).isEqualTo(MessageLikeEventType.RoomRedaction)
assertThat(MessageEventType.STICKER.map()).isEqualTo(MessageLikeEventType.STICKER) assertThat(MessageEventType.Sticker.map()).isEqualTo(MessageLikeEventType.Sticker)
assertThat(MessageEventType.POLL_END.map()).isEqualTo(MessageLikeEventType.POLL_END) assertThat(MessageEventType.PollEnd.map()).isEqualTo(MessageLikeEventType.PollEnd)
assertThat(MessageEventType.POLL_RESPONSE.map()).isEqualTo(MessageLikeEventType.POLL_RESPONSE) assertThat(MessageEventType.PollResponse.map()).isEqualTo(MessageLikeEventType.PollResponse)
assertThat(MessageEventType.POLL_START.map()).isEqualTo(MessageLikeEventType.POLL_START) assertThat(MessageEventType.PollStart.map()).isEqualTo(MessageLikeEventType.PollStart)
assertThat(MessageEventType.UNSTABLE_POLL_END.map()).isEqualTo(MessageLikeEventType.UNSTABLE_POLL_END) assertThat(MessageEventType.UnstablePollEnd.map()).isEqualTo(MessageLikeEventType.UnstablePollEnd)
assertThat(MessageEventType.UNSTABLE_POLL_RESPONSE.map()).isEqualTo(MessageLikeEventType.UNSTABLE_POLL_RESPONSE) assertThat(MessageEventType.UnstablePollResponse.map()).isEqualTo(MessageLikeEventType.UnstablePollResponse)
assertThat(MessageEventType.UNSTABLE_POLL_START.map()).isEqualTo(MessageLikeEventType.UNSTABLE_POLL_START) assertThat(MessageEventType.UnstablePollStart.map()).isEqualTo(MessageLikeEventType.UnstablePollStart)
} }
} }