diff --git a/rust/bt-mcs/src/types.rs b/rust/bt-mcs/src/types.rs
index ca765f5..cd49de0 100644
--- a/rust/bt-mcs/src/types.rs
+++ b/rust/bt-mcs/src/types.rs
@@ -42,7 +42,7 @@
 /// Media Control Point Opcodes Supported characteristic UUID.
 pub(crate) const MEDIA_CONTROL_POINT_OPCODES_SUPPORTED_UUID: Uuid = Uuid::from_u16(0x2BA5);
 /// Content Control ID (CCID) characteristic UUID.
-pub(crate) const CONTENT_CONTROL_ID_UUID: Uuid = Uuid::from_u16(0x2BA8);
+pub(crate) const CONTENT_CONTROL_ID_UUID: Uuid = Uuid::from_u16(0x2BBA);
 
 decodable_enum! {
     /// State of the media player.
@@ -127,20 +127,28 @@
 }
 
 decodable_enum! {
-    /// Playing order mode for media playback.
+    /// Playing order mode for media playback (MCS v1.0.1 Section 3.15, Table 3.3).
     pub enum PlayingOrder<u8, PacketError, OutOfRange> {
-        /// Play a single track once, then stop.
+        /// A single track is played once; there is no next track.
         SingleOnce = 0x01,
-        /// Play a single track repeatedly.
+        /// A single track is played repeatedly; the next track is the current track.
         SingleRepeat = 0x02,
-        /// Play all tracks in normal sequence once, then stop.
-        Normal = 0x03,
-        /// Play all tracks in normal sequence repeatedly.
-        NormalRepeat = 0x04,
-        /// Play all tracks in shuffled order once, then stop.
-        ShuffleOnce = 0x05,
-        /// Play all tracks in shuffled order repeatedly.
-        ShuffleRepeat = 0x06,
+        /// The tracks within a group are played once in track order.
+        InOrderOnce = 0x03,
+        /// The tracks within a group are played in track order repeatedly.
+        InOrderRepeat = 0x04,
+        /// The tracks within a group are played once only from the oldest first.
+        OldestOnce = 0x05,
+        /// The tracks within a group are played from the oldest first repeatedly.
+        OldestRepeat = 0x06,
+        /// The tracks within a group are played once only from the newest first.
+        NewestOnce = 0x07,
+        /// The tracks within a group are played from the newest first repeatedly.
+        NewestRepeat = 0x08,
+        /// The tracks within a group are played in random order once.
+        ShuffleOnce = 0x09,
+        /// The tracks within a group are played in random order repeatedly.
+        ShuffleRepeat = 0x0A,
     }
 }
 
@@ -172,15 +180,29 @@
 }
 
 bitflags! {
-    /// Bitmask representing supported playing orders (MCS v1.0.1 Section 3.10).
-    #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+    /// Bitmask representing supported playing orders (MCS v1.0.1 Section 3.16, Table 3.4).
+    #[derive(Debug, Clone, Copy, PartialEq, Eq)]
     pub struct SupportedPlayingOrders: u16 {
+        /// A single track is played once; there is no next track.
         const SINGLE_ONCE = 0x0001;
+        /// A single track is played repeatedly; the next track is the current track.
         const SINGLE_REPEAT = 0x0002;
-        const NORMAL = 0x0004;
-        const NORMAL_REPEAT = 0x0008;
-        const SHUFFLE_ONCE = 0x0010;
-        const SHUFFLE_REPEAT = 0x0020;
+        /// The tracks within a group are played once in track order.
+        const IN_ORDER_ONCE = 0x0004;
+        /// The tracks within a group are played in track order repeatedly.
+        const IN_ORDER_REPEAT = 0x0008;
+        /// The tracks within a group are played once only from the oldest first.
+        const OLDEST_ONCE = 0x0010;
+        /// The tracks within a group are played from the oldest first repeatedly.
+        const OLDEST_REPEAT = 0x0020;
+        /// The tracks within a group are played once only from the newest first.
+        const NEWEST_ONCE = 0x0040;
+        /// The tracks within a group are played from the newest first repeatedly.
+        const NEWEST_REPEAT = 0x0080;
+        /// The tracks within a group are played in random order once.
+        const SHUFFLE_ONCE = 0x0100;
+        /// The tracks within a group are played in random order repeatedly.
+        const SHUFFLE_REPEAT = 0x0200;
     }
 }
 
@@ -189,14 +211,24 @@
         match order {
             PlayingOrder::SingleOnce => Self::SINGLE_ONCE,
             PlayingOrder::SingleRepeat => Self::SINGLE_REPEAT,
-            PlayingOrder::Normal => Self::NORMAL,
-            PlayingOrder::NormalRepeat => Self::NORMAL_REPEAT,
+            PlayingOrder::InOrderOnce => Self::IN_ORDER_ONCE,
+            PlayingOrder::InOrderRepeat => Self::IN_ORDER_REPEAT,
+            PlayingOrder::OldestOnce => Self::OLDEST_ONCE,
+            PlayingOrder::OldestRepeat => Self::OLDEST_REPEAT,
+            PlayingOrder::NewestOnce => Self::NEWEST_ONCE,
+            PlayingOrder::NewestRepeat => Self::NEWEST_REPEAT,
             PlayingOrder::ShuffleOnce => Self::SHUFFLE_ONCE,
             PlayingOrder::ShuffleRepeat => Self::SHUFFLE_REPEAT,
         }
     }
 }
 
+impl From<&PlayingOrder> for SupportedPlayingOrders {
+    fn from(order: &PlayingOrder) -> Self {
+        Self::from(*order)
+    }
+}
+
 impl Encodable for SupportedPlayingOrders {
     type Error = PacketError;
 
@@ -225,7 +257,7 @@
     }
 }
 
-/// Media Control Point Opcode.
+/// Media Control Point Opcode (MCS v1.0.1 Section 3.18, Table 3.6).
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum MediaControlOpcode {
     /// Start playing current track.
@@ -238,7 +270,7 @@
     FastForward,
     /// Stop playback.
     Stop,
-    /// Move playback position relative to current position in seconds.
+    /// Move playback position relative to current position by offset.
     MoveRelative(i32),
     /// Jump to previous segment.
     PreviousSegment,
@@ -273,7 +305,7 @@
 }
 
 impl MediaControlOpcode {
-    /// Returns the raw 1-byte opcode value.
+    /// Returns the raw 1-byte opcode value defined in MCS v1.0.1 Table 3.6.
     pub fn raw_opcode(&self) -> u8 {
         match self {
             Self::Play => 0x01,
@@ -281,12 +313,12 @@
             Self::FastRewind => 0x03,
             Self::FastForward => 0x04,
             Self::Stop => 0x05,
-            Self::MoveRelative(_) => 0x20,
-            Self::PreviousSegment => 0x21,
-            Self::NextSegment => 0x22,
-            Self::FirstSegment => 0x23,
-            Self::LastSegment => 0x24,
-            Self::GotoSegment(_) => 0x25,
+            Self::MoveRelative(_) => 0x10,
+            Self::PreviousSegment => 0x20,
+            Self::NextSegment => 0x21,
+            Self::FirstSegment => 0x22,
+            Self::LastSegment => 0x23,
+            Self::GotoSegment(_) => 0x24,
             Self::PreviousTrack => 0x30,
             Self::NextTrack => 0x31,
             Self::FirstTrack => 0x32,
@@ -347,7 +379,7 @@
             0x03 => (Ok(Self::FastRewind), 1),
             0x04 => (Ok(Self::FastForward), 1),
             0x05 => (Ok(Self::Stop), 1),
-            0x20 => {
+            0x10 => {
                 if buf.len() < 5 {
                     (Err(PacketError::UnexpectedDataLength), buf.len())
                 } else {
@@ -355,11 +387,11 @@
                     (Ok(Self::MoveRelative(param)), 5)
                 }
             }
-            0x21 => (Ok(Self::PreviousSegment), 1),
-            0x22 => (Ok(Self::NextSegment), 1),
-            0x23 => (Ok(Self::FirstSegment), 1),
-            0x24 => (Ok(Self::LastSegment), 1),
-            0x25 => {
+            0x20 => (Ok(Self::PreviousSegment), 1),
+            0x21 => (Ok(Self::NextSegment), 1),
+            0x22 => (Ok(Self::FirstSegment), 1),
+            0x23 => (Ok(Self::LastSegment), 1),
+            0x24 => {
                 if buf.len() < 5 {
                     (Err(PacketError::UnexpectedDataLength), buf.len())
                 } else {
@@ -397,8 +429,8 @@
 }
 
 bitflags! {
-    /// Bitmask representing supported Media Control Point opcodes (MCS v1.0.1 Section 3.13).
-    #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+    /// Bitmask representing supported Media Control Point opcodes (MCS v1.0.1 Section 3.19, Table 3.10).
+    #[derive(Debug, Clone, Copy, PartialEq, Eq)]
     pub struct SupportedOpcodes: u32 {
         const PLAY = 0x00000001;
         const PAUSE = 0x00000002;
@@ -491,63 +523,175 @@
     use super::*;
 
     #[test]
-    fn test_media_state_encode_decode() {
-        for &state in MediaState::VARIANTS {
+    fn media_state_encode_decode_success() {
+        let states = [
+            (MediaState::Inactive, 0x00),
+            (MediaState::Playing, 0x01),
+            (MediaState::Paused, 0x02),
+            (MediaState::Seeking, 0x03),
+        ];
+
+        for (state, raw_byte) in states {
+            assert_eq!(u8::from(state), raw_byte);
+            assert_eq!(state.encoded_len(), 1);
+
             let mut buf = [0u8; 1];
             assert!(state.encode(&mut buf).is_ok());
+            assert_eq!(buf[0], raw_byte);
+
             let (decoded, consumed) = MediaState::decode(&buf);
             assert_eq!(consumed, 1);
             assert_eq!(decoded.unwrap(), state);
         }
+    }
 
+    #[test]
+    fn media_state_decode_error() {
         // Test out of range
-        let (err, consumed) = MediaState::decode(&[0xFF]);
-        assert_eq!(consumed, 1);
-        assert_eq!(err.unwrap_err(), PacketError::OutOfRange);
+        for &invalid in &[0x04, 0x05, 0xFF] {
+            let (err, consumed) = MediaState::decode(&[invalid]);
+            assert_eq!(consumed, 1);
+            assert_eq!(err.unwrap_err(), PacketError::OutOfRange);
+        }
 
         // Test empty buffer
         let (err, consumed) = MediaState::decode(&[]);
         assert_eq!(consumed, 0);
         assert_eq!(err.unwrap_err(), PacketError::UnexpectedDataLength);
+
+        // Test buffer too small for encode
+        let mut empty_buf = [0u8; 0];
+        assert_eq!(
+            MediaState::Playing.encode(&mut empty_buf).unwrap_err(),
+            PacketError::BufferTooSmall
+        );
     }
 
     #[test]
-    fn test_control_point_result_code_encode_decode() {
-        for &code in ControlPointResultCode::VARIANTS {
+    fn control_point_result_code_encode_decode_success() {
+        let codes = [
+            (ControlPointResultCode::Success, 0x01),
+            (ControlPointResultCode::OpcodeNotSupported, 0x02),
+            (ControlPointResultCode::MediaPlayerInactive, 0x03),
+            (ControlPointResultCode::CommandCannotBeCompleted, 0x04),
+        ];
+
+        for (code, raw_byte) in codes {
+            assert_eq!(u8::from(code), raw_byte);
+            assert_eq!(code.encoded_len(), 1);
+
             let mut buf = [0u8; 1];
             assert!(code.encode(&mut buf).is_ok());
+            assert_eq!(buf[0], raw_byte);
+
             let (decoded, consumed) = ControlPointResultCode::decode(&buf);
             assert_eq!(consumed, 1);
             assert_eq!(decoded.unwrap(), code);
         }
-
-        // Test out of range
-        let (err, consumed) = ControlPointResultCode::decode(&[0x00]);
-        assert_eq!(consumed, 1);
-        assert_eq!(err.unwrap_err(), PacketError::OutOfRange);
     }
 
     #[test]
-    fn test_playing_order_and_supported_bitmask() {
-        for &order in PlayingOrder::VARIANTS {
+    fn control_point_result_code_decode_error() {
+        // Test out of range
+        for &invalid in &[0x00, 0x05, 0x06, 0xFF] {
+            let (err, consumed) = ControlPointResultCode::decode(&[invalid]);
+            assert_eq!(consumed, 1);
+            assert_eq!(err.unwrap_err(), PacketError::OutOfRange);
+        }
+
+        // Test empty buffer
+        let (err, consumed) = ControlPointResultCode::decode(&[]);
+        assert_eq!(consumed, 0);
+        assert_eq!(err.unwrap_err(), PacketError::UnexpectedDataLength);
+
+        // Test buffer too small for encode
+        let mut empty_buf = [0u8; 0];
+        assert_eq!(
+            ControlPointResultCode::Success.encode(&mut empty_buf).unwrap_err(),
+            PacketError::BufferTooSmall
+        );
+    }
+
+    #[test]
+    fn playing_order_encode_decode_success() {
+        let orders = [
+            (PlayingOrder::SingleOnce, 0x01, SupportedPlayingOrders::SINGLE_ONCE),
+            (PlayingOrder::SingleRepeat, 0x02, SupportedPlayingOrders::SINGLE_REPEAT),
+            (PlayingOrder::InOrderOnce, 0x03, SupportedPlayingOrders::IN_ORDER_ONCE),
+            (PlayingOrder::InOrderRepeat, 0x04, SupportedPlayingOrders::IN_ORDER_REPEAT),
+            (PlayingOrder::OldestOnce, 0x05, SupportedPlayingOrders::OLDEST_ONCE),
+            (PlayingOrder::OldestRepeat, 0x06, SupportedPlayingOrders::OLDEST_REPEAT),
+            (PlayingOrder::NewestOnce, 0x07, SupportedPlayingOrders::NEWEST_ONCE),
+            (PlayingOrder::NewestRepeat, 0x08, SupportedPlayingOrders::NEWEST_REPEAT),
+            (PlayingOrder::ShuffleOnce, 0x09, SupportedPlayingOrders::SHUFFLE_ONCE),
+            (PlayingOrder::ShuffleRepeat, 0x0A, SupportedPlayingOrders::SHUFFLE_REPEAT),
+        ];
+
+        for (order, raw_byte, flag) in orders {
+            assert_eq!(u8::from(order), raw_byte);
+            assert_eq!(order.encoded_len(), 1);
+
             let mut buf = [0u8; 1];
             assert!(order.encode(&mut buf).is_ok());
+            assert_eq!(buf[0], raw_byte);
+
             let (decoded, consumed) = PlayingOrder::decode(&buf);
             assert_eq!(consumed, 1);
             assert_eq!(decoded.unwrap(), order);
+
+            let converted: SupportedPlayingOrders = order.into();
+            assert_eq!(converted, flag);
+            let converted_ref: SupportedPlayingOrders = (&order).into();
+            assert_eq!(converted_ref, flag);
+            assert!(SupportedPlayingOrders::all().contains(order.into()));
+        }
+    }
+
+    #[test]
+    fn playing_order_decode_error() {
+        // Test out of range
+        for &invalid in &[0x00, 0x0B, 0x10, 0xFF] {
+            let (err, consumed) = PlayingOrder::decode(&[invalid]);
+            assert_eq!(consumed, 1);
+            assert_eq!(err.unwrap_err(), PacketError::OutOfRange);
         }
 
+        // Test empty buffer
+        let (err, consumed) = PlayingOrder::decode(&[]);
+        assert_eq!(consumed, 0);
+        assert_eq!(err.unwrap_err(), PacketError::UnexpectedDataLength);
+
+        // Test buffer too small for encode
+        let mut empty_buf = [0u8; 0];
+        assert_eq!(
+            PlayingOrder::InOrderOnce.encode(&mut empty_buf).unwrap_err(),
+            PacketError::BufferTooSmall
+        );
+    }
+
+    #[test]
+    fn supported_playing_orders_bitmask_success() {
+        assert_eq!(SupportedPlayingOrders::all().bits(), 0x03FF);
+
         let supported = SupportedPlayingOrders::SINGLE_ONCE
-            | SupportedPlayingOrders::NORMAL
+            | SupportedPlayingOrders::IN_ORDER_ONCE
+            | SupportedPlayingOrders::OLDEST_ONCE
+            | SupportedPlayingOrders::NEWEST_REPEAT
             | SupportedPlayingOrders::SHUFFLE_REPEAT;
 
         assert!(supported.contains(PlayingOrder::SingleOnce.into()));
-        assert!(supported.contains(PlayingOrder::Normal.into()));
+        assert!(supported.contains(PlayingOrder::InOrderOnce.into()));
+        assert!(supported.contains(PlayingOrder::OldestOnce.into()));
+        assert!(supported.contains(PlayingOrder::NewestRepeat.into()));
         assert!(supported.contains(PlayingOrder::ShuffleRepeat.into()));
+
         assert!(!supported.contains(PlayingOrder::SingleRepeat.into()));
-        assert!(!supported.contains(PlayingOrder::NormalRepeat.into()));
+        assert!(!supported.contains(PlayingOrder::InOrderRepeat.into()));
+        assert!(!supported.contains(PlayingOrder::OldestRepeat.into()));
+        assert!(!supported.contains(PlayingOrder::NewestOnce.into()));
         assert!(!supported.contains(PlayingOrder::ShuffleOnce.into()));
 
+        // Encode and decode SupportedPlayingOrders
         let mut buf = [0u8; 2];
         assert!(supported.encode(&mut buf).is_ok());
         let (decoded, consumed) = SupportedPlayingOrders::decode(&buf);
@@ -556,17 +700,27 @@
     }
 
     #[test]
-    fn test_media_control_opcode_all_non_parameterized() {
+    fn supported_playing_orders_error() {
+        let supported = SupportedPlayingOrders::SINGLE_ONCE;
+        // Buffer too small for SupportedPlayingOrders encode/decode
+        assert_eq!(supported.encode(&mut [0u8; 1]).unwrap_err(), PacketError::BufferTooSmall);
+        let (err, consumed) = SupportedPlayingOrders::decode(&[0x01]);
+        assert_eq!(consumed, 0);
+        assert_eq!(err.unwrap_err(), PacketError::UnexpectedDataLength);
+    }
+
+    #[test]
+    fn media_control_opcode_all_non_parameterized() {
         let opcodes = [
             (MediaControlOpcode::Play, 0x01),
             (MediaControlOpcode::Pause, 0x02),
             (MediaControlOpcode::FastRewind, 0x03),
             (MediaControlOpcode::FastForward, 0x04),
             (MediaControlOpcode::Stop, 0x05),
-            (MediaControlOpcode::PreviousSegment, 0x21),
-            (MediaControlOpcode::NextSegment, 0x22),
-            (MediaControlOpcode::FirstSegment, 0x23),
-            (MediaControlOpcode::LastSegment, 0x24),
+            (MediaControlOpcode::PreviousSegment, 0x20),
+            (MediaControlOpcode::NextSegment, 0x21),
+            (MediaControlOpcode::FirstSegment, 0x22),
+            (MediaControlOpcode::LastSegment, 0x23),
             (MediaControlOpcode::PreviousTrack, 0x30),
             (MediaControlOpcode::NextTrack, 0x31),
             (MediaControlOpcode::FirstTrack, 0x32),
@@ -588,17 +742,28 @@
             let (decoded, consumed) = MediaControlOpcode::decode(&buf);
             assert_eq!(consumed, 1);
             assert_eq!(decoded.unwrap(), opcode);
+
+            // Buffer too small for encode
+            let mut empty = [0u8; 0];
+            assert_eq!(opcode.encode(&mut empty).unwrap_err(), PacketError::BufferTooSmall);
         }
     }
 
     #[test]
-    fn test_media_control_opcode_parameterized() {
+    fn media_control_opcode_parameterized() {
         let test_cases = [
-            (MediaControlOpcode::MoveRelative(10), 0x20, 10i32),
-            (MediaControlOpcode::MoveRelative(-15), 0x20, -15i32),
-            (MediaControlOpcode::GotoSegment(3), 0x25, 3i32),
+            (MediaControlOpcode::MoveRelative(10), 0x10, 10i32),
+            (MediaControlOpcode::MoveRelative(-15), 0x10, -15i32),
+            (MediaControlOpcode::MoveRelative(0), 0x10, 0i32),
+            (MediaControlOpcode::GotoSegment(3), 0x24, 3i32),
+            (MediaControlOpcode::GotoSegment(-1), 0x24, -1i32),
+            (MediaControlOpcode::GotoSegment(0), 0x24, 0i32),
             (MediaControlOpcode::GotoTrack(42), 0x34, 42i32),
+            (MediaControlOpcode::GotoTrack(-5), 0x34, -5i32),
+            (MediaControlOpcode::GotoTrack(0), 0x34, 0i32),
             (MediaControlOpcode::GotoGroup(1), 0x44, 1i32),
+            (MediaControlOpcode::GotoGroup(-2), 0x44, -2i32),
+            (MediaControlOpcode::GotoGroup(0), 0x44, 0i32),
         ];
 
         for (opcode, raw_byte, param) in test_cases {
@@ -613,20 +778,88 @@
             let (decoded, consumed) = MediaControlOpcode::decode(&buf);
             assert_eq!(consumed, 5);
             assert_eq!(decoded.unwrap(), opcode);
+
+            // Buffer too small for encode
+            let mut small = [0u8; 4];
+            assert_eq!(opcode.encode(&mut small).unwrap_err(), PacketError::BufferTooSmall);
         }
     }
 
     #[test]
-    fn test_media_control_opcode_truncated_buffer() {
-        // Opcode 0x20 (MoveRelative) requires 5 bytes, only 3 provided
-        let truncated = [0x20, 0x01, 0x02];
-        let (err, consumed) = MediaControlOpcode::decode(&truncated);
-        assert_eq!(consumed, 3);
+    fn media_control_opcode_truncated_and_invalid_buffers() {
+        // Opcode 0x10 (MoveRelative) requires 5 bytes
+        for len in 1..5 {
+            let buf = vec![0x10, 0x01, 0x02, 0x03];
+            let (err, consumed) = MediaControlOpcode::decode(&buf[..len]);
+            assert_eq!(consumed, len);
+            assert_eq!(err.unwrap_err(), PacketError::UnexpectedDataLength);
+        }
+
+        // Opcode 0x24 (GotoSegment) requires 5 bytes
+        let (err, consumed) = MediaControlOpcode::decode(&[0x24, 0x01]);
+        assert_eq!(consumed, 2);
+        assert_eq!(err.unwrap_err(), PacketError::UnexpectedDataLength);
+
+        // Opcode 0x34 (GotoTrack) requires 5 bytes
+        let (err, consumed) = MediaControlOpcode::decode(&[0x34, 0x01, 0x02, 0x03]);
+        assert_eq!(consumed, 4);
+        assert_eq!(err.unwrap_err(), PacketError::UnexpectedDataLength);
+
+        // Opcode 0x44 (GotoGroup) requires 5 bytes
+        let (err, consumed) = MediaControlOpcode::decode(&[0x44]);
+        assert_eq!(consumed, 1);
+        assert_eq!(err.unwrap_err(), PacketError::UnexpectedDataLength);
+
+        // Invalid / RFU opcodes
+        for &invalid in &[0x00, 0x06, 0x0F, 0x11, 0x1F, 0x25, 0x2F, 0x35, 0x3F, 0x45, 0xFF] {
+            let (err, consumed) = MediaControlOpcode::decode(&[invalid]);
+            assert_eq!(consumed, 1);
+            assert_eq!(err.unwrap_err(), PacketError::OutOfRange);
+        }
+
+        // Empty buffer
+        let (err, consumed) = MediaControlOpcode::decode(&[]);
+        assert_eq!(consumed, 0);
         assert_eq!(err.unwrap_err(), PacketError::UnexpectedDataLength);
     }
 
     #[test]
-    fn test_supported_opcodes_bitmask() {
+    fn supported_opcodes_bitmask_success() {
+        assert_eq!(SupportedOpcodes::all().bits(), 0x001F_FFFF);
+
+        let opcode_flags = [
+            (MediaControlOpcode::Play, SupportedOpcodes::PLAY, 0x00000001),
+            (MediaControlOpcode::Pause, SupportedOpcodes::PAUSE, 0x00000002),
+            (MediaControlOpcode::FastRewind, SupportedOpcodes::FAST_REWIND, 0x00000004),
+            (MediaControlOpcode::FastForward, SupportedOpcodes::FAST_FORWARD, 0x00000008),
+            (MediaControlOpcode::Stop, SupportedOpcodes::STOP, 0x00000010),
+            (MediaControlOpcode::MoveRelative(0), SupportedOpcodes::MOVE_RELATIVE, 0x00000020),
+            (MediaControlOpcode::PreviousSegment, SupportedOpcodes::PREVIOUS_SEGMENT, 0x00000040),
+            (MediaControlOpcode::NextSegment, SupportedOpcodes::NEXT_SEGMENT, 0x00000080),
+            (MediaControlOpcode::FirstSegment, SupportedOpcodes::FIRST_SEGMENT, 0x00000100),
+            (MediaControlOpcode::LastSegment, SupportedOpcodes::LAST_SEGMENT, 0x00000200),
+            (MediaControlOpcode::GotoSegment(0), SupportedOpcodes::GOTO_SEGMENT, 0x00000400),
+            (MediaControlOpcode::PreviousTrack, SupportedOpcodes::PREVIOUS_TRACK, 0x00000800),
+            (MediaControlOpcode::NextTrack, SupportedOpcodes::NEXT_TRACK, 0x00001000),
+            (MediaControlOpcode::FirstTrack, SupportedOpcodes::FIRST_TRACK, 0x00002000),
+            (MediaControlOpcode::LastTrack, SupportedOpcodes::LAST_TRACK, 0x00004000),
+            (MediaControlOpcode::GotoTrack(0), SupportedOpcodes::GOTO_TRACK, 0x00008000),
+            (MediaControlOpcode::PreviousGroup, SupportedOpcodes::PREVIOUS_GROUP, 0x00010000),
+            (MediaControlOpcode::NextGroup, SupportedOpcodes::NEXT_GROUP, 0x00020000),
+            (MediaControlOpcode::FirstGroup, SupportedOpcodes::FIRST_GROUP, 0x00040000),
+            (MediaControlOpcode::LastGroup, SupportedOpcodes::LAST_GROUP, 0x00080000),
+            (MediaControlOpcode::GotoGroup(0), SupportedOpcodes::GOTO_GROUP, 0x00100000),
+        ];
+
+        for (opcode, flag, bits) in opcode_flags {
+            assert_eq!(flag.bits(), bits);
+            let converted: SupportedOpcodes = opcode.into();
+            assert_eq!(converted, flag);
+            let converted_ref: SupportedOpcodes = (&opcode).into();
+            assert_eq!(converted_ref, flag);
+            assert!(SupportedOpcodes::all().contains(flag));
+        }
+
         let supported = SupportedOpcodes::PLAY
             | SupportedOpcodes::PAUSE
             | SupportedOpcodes::MOVE_RELATIVE
@@ -646,4 +879,14 @@
         assert_eq!(consumed, 4);
         assert_eq!(decoded.unwrap(), supported);
     }
+
+    #[test]
+    fn supported_opcodes_error() {
+        let supported = SupportedOpcodes::PLAY;
+        // Buffer too small for SupportedOpcodes encode/decode
+        assert_eq!(supported.encode(&mut [0u8; 3]).unwrap_err(), PacketError::BufferTooSmall);
+        let (err, consumed) = SupportedOpcodes::decode(&[0x01, 0x02, 0x03]);
+        assert_eq!(consumed, 0);
+        assert_eq!(err.unwrap_err(), PacketError::UnexpectedDataLength);
+    }
 }