ot-tools-io 0.7.0

/*
SPDX-License-Identifier: GPL-3.0-or-later
Copyright © 2024 Mike Robeson [dijksterhuis]
*/

//! Settings enums. Mostly related to [`crate::SampleSettingsFile`],
//! [`crate::projects::SlotAttributes`] and [`crate::MarkersFile`] types.

use ot_tools_io_derive::{
    enum_try_from_i32_to_signed_types, enum_try_from_u32_to_unsigned_types, AsMutDerive,
    AsRefDerive, IntoSigneds, IntoUnsigneds,
};
use serde::{Deserialize, Serialize};
use std::fmt::Display;
use thiserror::Error;

/// Errors when parsing a value with [`TryFrom`] for some Enum
#[derive(Debug, Error)]
pub enum InvalidValueError {
    /// Error when parsing values with [`TimeStretchMode::try_from`]
    #[error(
        "invalid time stretch value, only '0' (Off), '2' (Normal) and '3' (Beat) are supported values"
    )]
    TimeStretchMode,

    /// Error when parsing values with [`LoopMode::try_from`]
    #[error(
        "invalid loop mode value, only '0' (Off), '1' (Normal) and '2' (PingPong) are supported values"
    )]
    LoopMode,

    /// Error when parsing values with [`TrigQuantizationMode::try_from`]
    #[error("invalid trig quantization value")]
    TrigQuantizationMode,

    /// Error when parsing values with [`TrigCondition::try_from`]
    #[error("invalid trig condition value")]
    TrigCondition,

    /// Error when parsing values with [`ProgChMidiChannel::try_from`]
    #[error("invalid Program Change MIDI Channel value")]
    ProgChMidiChannel,

    /// Error when parsing values with [`SlotType::try_from`]
    #[error("invalid slot type value, only 'FLEX' and 'STATIC' are supported values")]
    SlotType,
}

/// Sample Time Stretch options.
/// See Octatrack Manual section 13.2.4 ATTRIBUTES
#[derive(
    Copy,
    Clone,
    Debug,
    Default,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
    Serialize,
    Deserialize,
    AsMutDerive,
    AsRefDerive,
    IntoUnsigneds,
)]
#[repr(u8)]
pub enum TimeStretchMode {
    /// No time-stretching applied.
    Off = 0,

    /// Regular time-stretching.
    #[default]
    Normal = 2,

    /// Drum / Rhythmic specific algorithm
    Beat = 3,
}

#[enum_try_from_u32_to_unsigned_types]
impl TryFrom<u32> for TimeStretchMode {
    type Error = InvalidValueError;
    fn try_from(value: u32) -> Result<Self, Self::Error> {
        match value {
            0 => Ok(TimeStretchMode::Off),
            2 => Ok(TimeStretchMode::Normal),
            3 => Ok(TimeStretchMode::Beat),
            _ => Err(InvalidValueError::TimeStretchMode),
        }
    }
}

#[cfg(test)]
mod ot_time_stretch_mode {
    mod value {
        use crate::settings::TimeStretchMode;

        #[test]
        fn test_off_value() {
            assert_eq!(TimeStretchMode::Off as u8, 0_u8);
        }
        #[test]
        fn test_normal_value() {
            assert_eq!(TimeStretchMode::Normal as u8, 2_u8);
        }
        #[test]
        fn test_beat_value() {
            assert_eq!(TimeStretchMode::Beat as u8, 3_u8);
        }
    }

    mod from_value {
        use crate::settings::TimeStretchMode;

        #[test]
        fn test_error() {
            // not in a sequential range with other values
            // dunno why they implemented it to skip value of 1, possible bug or easter egg?
            assert!(TimeStretchMode::try_from(&1_u8).is_err());
            assert_eq!(TimeStretchMode::try_from(&1_u8).unwrap_err().to_string(),  "invalid time stretch value, only '0' (Off), '2' (Normal) and '3' (Beat) are supported values");
            for x in 4..u8::MAX {
                assert!(TimeStretchMode::try_from(&x).is_err());
                assert_eq!(TimeStretchMode::try_from(&x).unwrap_err().to_string(),  "invalid time stretch value, only '0' (Off), '2' (Normal) and '3' (Beat) are supported values");
            }
        }
        #[test]
        fn test_off_from_value() {
            assert_eq!(
                TimeStretchMode::Off,
                TimeStretchMode::try_from(&0_u8).unwrap()
            );
        }
        #[test]
        fn test_normal_from_value() {
            assert_eq!(
                TimeStretchMode::Normal,
                TimeStretchMode::try_from(&2_u8).unwrap()
            );
        }
        #[test]
        fn test_beat_from_value() {
            assert_eq!(
                TimeStretchMode::Beat,
                TimeStretchMode::try_from(&3_u8).unwrap()
            );
        }
    }
}

/// Sample attributes Loop mode options.
/// See Octatrack Manual section 13.2.4 ATTRIBUTES
#[derive(
    Copy,
    Clone,
    Debug,
    Default,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
    Serialize,
    Deserialize,
    AsMutDerive,
    AsRefDerive,
    IntoUnsigneds,
)]
#[repr(u8)]
pub enum LoopMode {
    /// Loop points are ignored and sample will never loop.
    #[default]
    Off = 0,

    /// Loop by starting again at the loop start position once playback of the sample reaches loop end.
    Normal = 1,

    /// Loop by continuously reversing once playback of the sample reaches loop end/loop start.
    PingPong = 2,
}

#[enum_try_from_u32_to_unsigned_types]
impl TryFrom<u32> for LoopMode {
    type Error = InvalidValueError;
    fn try_from(value: u32) -> Result<Self, Self::Error> {
        match value {
            0 => Ok(LoopMode::Off),
            1 => Ok(LoopMode::Normal),
            2 => Ok(LoopMode::PingPong),
            _ => Err(InvalidValueError::LoopMode),
        }
    }
}

#[cfg(test)]
mod ot_loop_mode {

    mod value {
        use crate::settings::LoopMode;

        #[test]
        fn test_off_value() {
            assert_eq!(LoopMode::Off as u8, 0_u8);
        }
        #[test]
        fn test_normal_value() {
            assert_eq!(LoopMode::Normal as u8, 1_u8);
        }
        #[test]
        fn test_beat_value() {
            assert_eq!(LoopMode::PingPong as u8, 2_u8);
        }
    }

    mod from_value {
        use crate::settings::LoopMode;

        #[test]
        fn test_error() {
            for x in 3..u8::MAX {
                assert!(LoopMode::try_from(&x).is_err());
                assert_eq!(LoopMode::try_from(&x).unwrap_err().to_string(), "invalid loop mode value, only '0' (Off), '1' (Normal) and '2' (PingPong) are supported values");
            }
        }
        #[test]
        fn test_off_from_value() {
            assert_eq!(LoopMode::Off, LoopMode::try_from(&0_u8).unwrap());
        }
        #[test]
        fn test_normal_from_value() {
            assert_eq!(LoopMode::Normal, LoopMode::try_from(&1_u8).unwrap());
        }
        #[test]
        fn test_beat_from_value() {
            assert_eq!(LoopMode::PingPong, LoopMode::try_from(&2_u8).unwrap());
        }
    }
}

/// Sample attributes Trig Quantization options
/// (quantization when manually triggering samples via track buttons).
/// See Octatrack Manual section 13.2.4 ATTRIBUTES
#[derive(
    Copy,
    Clone,
    Debug,
    Default,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
    Serialize,
    Deserialize,
    AsMutDerive,
    AsRefDerive,
    IntoUnsigneds,
)]
#[repr(u8)]
pub enum TrigQuantizationMode {
    /// Play back immediately, no quantization.
    #[default]
    Direct = 255,

    /// Play once the pattern ends
    PatternLength = 0,

    /// Play after 1 sequencer step(s).
    OneStep = 1,

    /// Play after 2 sequencer step(s).
    TwoSteps = 2,

    /// Play after 3 sequencer step(s).
    ThreeSteps = 3,

    /// Play after 4 sequencer step(s).
    FourSteps = 4,

    /// Play after 6 sequencer step(s).
    SixSteps = 5,

    /// Play after 8 sequencer step(s).
    EightSteps = 6,

    /// Play after 12 sequencer step(s).
    TwelveSteps = 7,

    /// Play after 16 sequencer step(s).
    SixteenSteps = 8,

    /// Play after 24 sequencer step(s).
    TwentyFourSteps = 9,

    /// Play after 32 sequencer step(s).
    ThirtyTwoSteps = 10,

    /// Play after 48 sequencer step(s).
    FortyEightSteps = 11,

    /// Play after 64 sequencer step(s).
    SixtyFourSteps = 12,

    /// Play after 96 sequencer step(s).
    NinetySixSteps = 13,

    /// Play after 128 sequencer step(s).
    OneTwentyEightSteps = 14,

    /// Play after 192 sequencer step(s).
    OneNinetyTwoSteps = 15,

    /// Play after 256 sequencer step(s).
    TwoFiveSixSteps = 16,
}

#[enum_try_from_u32_to_unsigned_types]
impl TryFrom<u32> for TrigQuantizationMode {
    type Error = InvalidValueError;
    fn try_from(value: u32) -> Result<Self, Self::Error> {
        match value {
            255 => Ok(TrigQuantizationMode::Direct),
            0 => Ok(TrigQuantizationMode::PatternLength),
            1 => Ok(TrigQuantizationMode::OneStep),
            2 => Ok(TrigQuantizationMode::TwoSteps),
            3 => Ok(TrigQuantizationMode::ThreeSteps),
            4 => Ok(TrigQuantizationMode::FourSteps),
            5 => Ok(TrigQuantizationMode::SixSteps),
            6 => Ok(TrigQuantizationMode::EightSteps),
            7 => Ok(TrigQuantizationMode::TwelveSteps),
            8 => Ok(TrigQuantizationMode::SixteenSteps),
            9 => Ok(TrigQuantizationMode::TwentyFourSteps),
            10 => Ok(TrigQuantizationMode::ThirtyTwoSteps),
            11 => Ok(TrigQuantizationMode::FortyEightSteps),
            12 => Ok(TrigQuantizationMode::SixtyFourSteps),
            13 => Ok(TrigQuantizationMode::NinetySixSteps),
            14 => Ok(TrigQuantizationMode::OneTwentyEightSteps),
            15 => Ok(TrigQuantizationMode::OneNinetyTwoSteps),
            16 => Ok(TrigQuantizationMode::TwoFiveSixSteps),
            _ => Err(InvalidValueError::TrigQuantizationMode),
        }
    }
}

#[cfg(test)]
mod ot_trig_quantize_mode {

    mod value {
        use crate::settings::TrigQuantizationMode;

        #[test]
        fn test_direct() {
            assert_eq!(TrigQuantizationMode::Direct as u8, 255);
        }
        #[test]
        fn test_patternlen() {
            assert_eq!(TrigQuantizationMode::PatternLength as u8, 0);
        }
        #[test]
        fn test_1() {
            assert_eq!(TrigQuantizationMode::OneStep as u8, 1);
        }
        #[test]
        fn test_2() {
            assert_eq!(TrigQuantizationMode::TwoSteps as u8, 2);
        }
        #[test]
        fn test_3() {
            assert_eq!(TrigQuantizationMode::ThreeSteps as u8, 3);
        }
        #[test]
        fn test_4() {
            assert_eq!(TrigQuantizationMode::FourSteps as u8, 4);
        }
        #[test]
        fn test_6() {
            assert_eq!(TrigQuantizationMode::SixSteps as u8, 5);
        }
        #[test]
        fn test_8() {
            assert_eq!(TrigQuantizationMode::EightSteps as u8, 6);
        }
        #[test]
        fn test_12() {
            assert_eq!(TrigQuantizationMode::TwelveSteps as u8, 7);
        }
        #[test]
        fn test_16() {
            assert_eq!(TrigQuantizationMode::SixteenSteps as u8, 8);
        }
        #[test]
        fn test_24() {
            assert_eq!(TrigQuantizationMode::TwentyFourSteps as u8, 9);
        }
        #[test]
        fn test_32() {
            assert_eq!(TrigQuantizationMode::ThirtyTwoSteps as u8, 10);
        }
        #[test]
        fn test_48() {
            assert_eq!(TrigQuantizationMode::FortyEightSteps as u8, 11);
        }
        #[test]
        fn test_64() {
            assert_eq!(TrigQuantizationMode::SixtyFourSteps as u8, 12);
        }
        #[test]
        fn test_96() {
            assert_eq!(TrigQuantizationMode::NinetySixSteps as u8, 13);
        }
        #[test]
        fn test_128() {
            assert_eq!(TrigQuantizationMode::OneTwentyEightSteps as u8, 14);
        }
        #[test]
        fn test_192() {
            assert_eq!(TrigQuantizationMode::OneNinetyTwoSteps as u8, 15);
        }
        #[test]
        fn test_256() {
            assert_eq!(TrigQuantizationMode::TwoFiveSixSteps as u8, 16);
        }
    }

    mod from_value {
        use crate::settings::TrigQuantizationMode;

        #[test]
        fn test_error() {
            for i in 17..=254_u8 {
                assert!(TrigQuantizationMode::try_from(i).is_err());
                assert_eq!(
                    TrigQuantizationMode::try_from(i).unwrap_err().to_string(),
                    "invalid trig quantization value"
                );
            }
        }
        #[test]
        fn test_direct() {
            assert_eq!(
                TrigQuantizationMode::Direct,
                TrigQuantizationMode::try_from(255_u8).unwrap()
            );
        }
        #[test]
        fn test_patternlen() {
            assert_eq!(
                TrigQuantizationMode::PatternLength,
                TrigQuantizationMode::try_from(0_u8).unwrap()
            );
        }
        #[test]
        fn test_1() {
            assert_eq!(
                TrigQuantizationMode::OneStep,
                TrigQuantizationMode::try_from(1_u8).unwrap()
            );
        }
        #[test]
        fn test_2() {
            assert_eq!(
                TrigQuantizationMode::TwoSteps,
                TrigQuantizationMode::try_from(2_u8).unwrap()
            );
        }
        #[test]
        fn test_3() {
            assert_eq!(
                TrigQuantizationMode::ThreeSteps,
                TrigQuantizationMode::try_from(3_u8).unwrap()
            );
        }
        #[test]
        fn test_4() {
            assert_eq!(
                TrigQuantizationMode::FourSteps,
                TrigQuantizationMode::try_from(4_u8).unwrap()
            );
        }
        #[test]
        fn test_6() {
            assert_eq!(
                TrigQuantizationMode::SixSteps,
                TrigQuantizationMode::try_from(5_u8).unwrap()
            );
        }
        #[test]
        fn test_8() {
            assert_eq!(
                TrigQuantizationMode::EightSteps,
                TrigQuantizationMode::try_from(6_u8).unwrap()
            );
        }
        #[test]
        fn test_12() {
            assert_eq!(
                TrigQuantizationMode::TwelveSteps,
                TrigQuantizationMode::try_from(7_u8).unwrap()
            );
        }
        #[test]
        fn test_16() {
            assert_eq!(
                TrigQuantizationMode::SixteenSteps,
                TrigQuantizationMode::try_from(8_u8).unwrap()
            );
        }
        #[test]
        fn test_24() {
            assert_eq!(
                TrigQuantizationMode::TwentyFourSteps,
                TrigQuantizationMode::try_from(9_u8).unwrap()
            );
        }
        #[test]
        fn test_32() {
            assert_eq!(
                TrigQuantizationMode::ThirtyTwoSteps,
                TrigQuantizationMode::try_from(10_u8).unwrap()
            );
        }
        #[test]
        fn test_48() {
            assert_eq!(
                TrigQuantizationMode::FortyEightSteps,
                TrigQuantizationMode::try_from(11_u8).unwrap()
            );
        }
        #[test]
        fn test_64() {
            assert_eq!(
                TrigQuantizationMode::SixtyFourSteps,
                TrigQuantizationMode::try_from(12_u8).unwrap()
            );
        }
        #[test]
        fn test_96() {
            assert_eq!(
                TrigQuantizationMode::NinetySixSteps,
                TrigQuantizationMode::try_from(13_u8).unwrap()
            );
        }
        #[test]
        fn test_128() {
            assert_eq!(
                TrigQuantizationMode::OneTwentyEightSteps,
                TrigQuantizationMode::try_from(14_u8).unwrap()
            );
        }
        #[test]
        fn test_192() {
            assert_eq!(
                TrigQuantizationMode::OneNinetyTwoSteps,
                TrigQuantizationMode::try_from(15_u8).unwrap()
            );
        }
        #[test]
        fn test_256() {
            assert_eq!(
                TrigQuantizationMode::TwoFiveSixSteps,
                TrigQuantizationMode::try_from(16_u8).unwrap()
            );
        }
    }
}

/// Sample Slot options for Projects.
#[derive(
    Copy,
    Clone,
    Debug,
    Default,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
    Serialize,
    Deserialize,
    AsMutDerive,
    AsRefDerive,
    IntoUnsigneds,
)]
pub enum TrigCondition {
    // Uses implicit discriminants to increment values from 0 -> 64 (inclusive)
    // https://doc.rust-lang.org/stable/reference/items/enumerations.html#implicit-discriminants
    #[default]
    None = 0,
    /// > FILL is true (will activate the trig) when fill mode is active (see below).
    Fill,
    /// > ... true when FILL is not.
    NotFill,
    /// > PRE is true if the most recently evaluated trig condition on the same track was true.
    Pre,
    /// > ... true when PRE is not.
    NotPre,
    /// > true if the most recently evaluated trig condition on the neighbor track was true.
    /// > The neighbor track is the track before the one being edited.
    /// > For example, the neighbor track of track 4 is track 3. If no conditions exist on the
    /// > neighbor track, the condition is false.
    Nei,
    /// > ... true when NEI is not.
    NotNei,
    /// > only true the first time the pattern play (when looped).
    First,
    /// > ... true when 1st is not.
    NotFirst,
    /// > probability condition. 1% chance of being true.
    Percent1,
    /// > probability condition. 2% chance of being true.
    Percent2,
    /// > probability condition. 4% chance of being true.
    Percent4,
    /// > probability condition. 6% chance of being true.
    Percent6,
    /// > probability condition. 9% chance of being true.
    Percent9,
    /// > probability condition. 13% chance of being true.
    Percent13,
    /// > probability condition. 19% chance of being true.
    Percent19,
    /// > probability condition. 25% chance of being true.
    Percent25,
    /// > probability condition. 33% chance of being true.
    Percent33,
    /// > probability condition. 41% chance of being true.
    Percent41,
    /// > probability condition. 50% chance of being true.
    Percent50,
    /// > probability condition. 59% chance of being true.
    Percent59,
    /// > probability condition. 67% chance of being true.
    Percent67,
    /// > probability condition. 75% chance of being true.
    Percent75,
    /// > probability condition. 81% chance of being true.
    Percent81,
    /// > probability condition. 87% chance of being true.
    Percent87,
    /// > probability condition. 91% chance of being true.
    Percent91,
    /// > probability condition. 94% chance of being true.
    Percent94,
    /// > probability condition. 96% chance of being true.
    Percent96,
    /// > probability condition. 98% chance of being true.
    Percent98,
    /// > probability condition. 99% chance of being true.
    Percent99,
    /// pattern loop 1 triggers, pattern loop 2 resets
    PatternT1R2,
    /// pattern loop 2 triggers, pattern loop 2 resets
    PatternT2R2,
    /// pattern loop 1 triggers, pattern loop 3 resets
    PatternT1R3,
    /// pattern loop 2 triggers, pattern loop 3 resets
    PatternT2R3,
    /// pattern loop 3 triggers, pattern loop 3 resets
    PatternT3R3,
    /// pattern loop 1 triggers, pattern loop 4 resets
    PatternT1R4,
    /// pattern loop 2 triggers, pattern loop 4 resets
    PatternT2R4,
    /// pattern loop 3 triggers, pattern loop 4 resets
    PatternT3R4,
    /// pattern loop 4 triggers, pattern loop 4 resets
    PatternT4R4,
    /// pattern loop 1 triggers, pattern loop 5 resets
    PatternT1R5,
    /// pattern loop 2 triggers, pattern loop 5 resets
    PatternT2R5,
    /// pattern loop 3 triggers, pattern loop 5 resets
    PatternT3R5,
    /// pattern loop 4 triggers, pattern loop 5 resets
    PatternT4R5,
    /// pattern loop 5 triggers, pattern loop 5 resets
    PatternT5R5,
    /// pattern loop 1 triggers, pattern loop 6 resets
    PatternT1R6,
    /// pattern loop 2 triggers, pattern loop 6 resets
    PatternT2R6,
    /// pattern loop 3 triggers, pattern loop 6 resets
    PatternT3R6,
    /// pattern loop 4 triggers, pattern loop 6 resets
    PatternT4R6,
    /// pattern loop 5 triggers, pattern loop 6 resets
    PatternT5R6,
    /// pattern loop 6 triggers, pattern loop 6 resets
    PatternT6R6,
    /// pattern loop 1 triggers, pattern loop 7 resets
    PatternT1R7,
    /// pattern loop 2 triggers, pattern loop 7 resets
    PatternT2R7,
    /// pattern loop 3 triggers, pattern loop 7 resets
    PatternT3R7,
    /// pattern loop 4 triggers, pattern loop 7 resets
    PatternT4R7,
    /// pattern loop 5 triggers, pattern loop 7 resets
    PatternT5R7,
    /// pattern loop 6 triggers, pattern loop 7 resets
    PatternT6R7,
    /// pattern loop 7 triggers, pattern loop 7 resets
    PatternT7R7,
    /// pattern loop 1 triggers, pattern loop 8 resets
    PatternT1R8,
    /// pattern loop 2 triggers, pattern loop 8 resets
    PatternT2R8,
    /// pattern loop 3 triggers, pattern loop 8 resets
    PatternT3R8,
    /// pattern loop 4 triggers, pattern loop 8 resets
    PatternT4R8,
    /// pattern loop 5 triggers, pattern loop 8 resets
    PatternT5R8,
    /// pattern loop 6 triggers, pattern loop 8 resets
    PatternT6R8,
    /// pattern loop 7 triggers, pattern loop 8 resets
    PatternT7R8,
    /// pattern loop 8 triggers, pattern loop 8 resets
    PatternT8R8,
}

#[enum_try_from_u32_to_unsigned_types]
impl TryFrom<u32> for TrigCondition {
    type Error = InvalidValueError;
    fn try_from(value: u32) -> Result<Self, Self::Error> {
        // read the essay for `AudioTrackTrigs.trig_timings_repeats_conditions`
        // to understand why rem_euclid is used here
        match value.rem_euclid(128) {
            0 => Ok(TrigCondition::None),
            1 => Ok(TrigCondition::Fill),
            2 => Ok(TrigCondition::NotFill),
            3 => Ok(TrigCondition::Pre),
            4 => Ok(TrigCondition::NotPre),
            5 => Ok(TrigCondition::Nei),
            6 => Ok(TrigCondition::NotNei),
            7 => Ok(TrigCondition::First),
            8 => Ok(TrigCondition::NotFirst),
            //
            9 => Ok(TrigCondition::Percent1),
            10 => Ok(TrigCondition::Percent2),
            11 => Ok(TrigCondition::Percent4),
            12 => Ok(TrigCondition::Percent6),
            13 => Ok(TrigCondition::Percent9),
            14 => Ok(TrigCondition::Percent13),
            15 => Ok(TrigCondition::Percent19),
            16 => Ok(TrigCondition::Percent25),
            17 => Ok(TrigCondition::Percent33),
            18 => Ok(TrigCondition::Percent41),
            19 => Ok(TrigCondition::Percent50),
            20 => Ok(TrigCondition::Percent59),
            21 => Ok(TrigCondition::Percent67),
            22 => Ok(TrigCondition::Percent75),
            23 => Ok(TrigCondition::Percent81),
            24 => Ok(TrigCondition::Percent87),
            25 => Ok(TrigCondition::Percent91),
            26 => Ok(TrigCondition::Percent94),
            27 => Ok(TrigCondition::Percent96),
            28 => Ok(TrigCondition::Percent98),
            29 => Ok(TrigCondition::Percent99),
            //
            30 => Ok(TrigCondition::PatternT1R2),
            31 => Ok(TrigCondition::PatternT2R2),
            //
            32 => Ok(TrigCondition::PatternT1R3),
            33 => Ok(TrigCondition::PatternT2R3),
            34 => Ok(TrigCondition::PatternT3R3),
            //
            35 => Ok(TrigCondition::PatternT1R4),
            36 => Ok(TrigCondition::PatternT2R4),
            37 => Ok(TrigCondition::PatternT3R4),
            38 => Ok(TrigCondition::PatternT4R4),
            //
            39 => Ok(TrigCondition::PatternT1R5),
            40 => Ok(TrigCondition::PatternT2R5),
            41 => Ok(TrigCondition::PatternT3R5),
            42 => Ok(TrigCondition::PatternT4R5),
            43 => Ok(TrigCondition::PatternT5R5),
            //
            44 => Ok(TrigCondition::PatternT1R6),
            45 => Ok(TrigCondition::PatternT2R6),
            46 => Ok(TrigCondition::PatternT3R6),
            47 => Ok(TrigCondition::PatternT4R6),
            48 => Ok(TrigCondition::PatternT5R6),
            49 => Ok(TrigCondition::PatternT6R6),
            //
            50 => Ok(TrigCondition::PatternT1R7),
            51 => Ok(TrigCondition::PatternT2R7),
            52 => Ok(TrigCondition::PatternT3R7),
            53 => Ok(TrigCondition::PatternT4R7),
            54 => Ok(TrigCondition::PatternT5R7),
            55 => Ok(TrigCondition::PatternT6R7),
            56 => Ok(TrigCondition::PatternT7R7),
            //
            57 => Ok(TrigCondition::PatternT1R8),
            58 => Ok(TrigCondition::PatternT2R8),
            59 => Ok(TrigCondition::PatternT3R8),
            60 => Ok(TrigCondition::PatternT4R8),
            61 => Ok(TrigCondition::PatternT5R8),
            62 => Ok(TrigCondition::PatternT6R8),
            63 => Ok(TrigCondition::PatternT7R8),
            64 => Ok(TrigCondition::PatternT8R8),
            //
            _ => Err(InvalidValueError::TrigCondition),
        }
    }
}

#[cfg(test)]
mod test_spec_trig_condition {

    mod from_value {
        use crate::settings::TrigCondition;

        #[test]
        fn none() {
            assert_eq!(TrigCondition::None, TrigCondition::try_from(&0_u8).unwrap())
        }
        #[test]
        fn fill() {
            assert_eq!(TrigCondition::Fill, TrigCondition::try_from(&1_u8).unwrap())
        }
        #[test]
        fn notfill() {
            assert_eq!(
                TrigCondition::NotFill,
                TrigCondition::try_from(&2_u8).unwrap()
            )
        }
        #[test]
        fn pre() {
            assert_eq!(TrigCondition::Pre, TrigCondition::try_from(&3_u8).unwrap())
        }
        #[test]
        fn notpre() {
            assert_eq!(
                TrigCondition::NotPre,
                TrigCondition::try_from(&4_u8).unwrap()
            )
        }
        #[test]
        fn nei() {
            assert_eq!(TrigCondition::Nei, TrigCondition::try_from(&5_u8).unwrap())
        }
        #[test]
        fn notnei() {
            assert_eq!(
                TrigCondition::NotNei,
                TrigCondition::try_from(&6_u8).unwrap()
            )
        }
        #[test]
        fn first() {
            assert_eq!(
                TrigCondition::First,
                TrigCondition::try_from(&7_u8).unwrap()
            )
        }
        #[test]
        fn notfirst() {
            assert_eq!(
                TrigCondition::NotFirst,
                TrigCondition::try_from(&8_u8).unwrap()
            )
        }
        #[test]
        fn perc1() {
            assert_eq!(
                TrigCondition::Percent1,
                TrigCondition::try_from(&9_u8).unwrap()
            )
        }
        #[test]
        fn perc2() {
            assert_eq!(
                TrigCondition::Percent2,
                TrigCondition::try_from(&10_u8).unwrap()
            )
        }
        #[test]
        fn perc4() {
            assert_eq!(
                TrigCondition::Percent4,
                TrigCondition::try_from(&11_u8).unwrap()
            )
        }
        #[test]
        fn perc6() {
            assert_eq!(
                TrigCondition::Percent6,
                TrigCondition::try_from(&12_u8).unwrap()
            )
        }
        #[test]
        fn perc9() {
            assert_eq!(
                TrigCondition::Percent9,
                TrigCondition::try_from(&13_u8).unwrap()
            )
        }
        #[test]
        fn perc13() {
            assert_eq!(
                TrigCondition::Percent13,
                TrigCondition::try_from(&14_u8).unwrap()
            )
        }
        #[test]
        fn perc19() {
            assert_eq!(
                TrigCondition::Percent19,
                TrigCondition::try_from(&15_u8).unwrap()
            )
        }
        #[test]
        fn perc25() {
            assert_eq!(
                TrigCondition::Percent25,
                TrigCondition::try_from(&16_u8).unwrap()
            )
        }
        #[test]
        fn perc33() {
            assert_eq!(
                TrigCondition::Percent33,
                TrigCondition::try_from(&17_u8).unwrap()
            )
        }
        #[test]
        fn perc41() {
            assert_eq!(
                TrigCondition::Percent41,
                TrigCondition::try_from(&18_u8).unwrap()
            )
        }
        #[test]
        fn perc50() {
            assert_eq!(
                TrigCondition::Percent50,
                TrigCondition::try_from(&19_u8).unwrap()
            )
        }
        #[test]
        fn perc59() {
            assert_eq!(
                TrigCondition::Percent59,
                TrigCondition::try_from(&20_u8).unwrap()
            )
        }
        #[test]
        fn perc67() {
            assert_eq!(
                TrigCondition::Percent67,
                TrigCondition::try_from(&21_u8).unwrap()
            )
        }
        #[test]
        fn perc75() {
            assert_eq!(
                TrigCondition::Percent75,
                TrigCondition::try_from(&22_u8).unwrap()
            )
        }
        #[test]
        fn perc81() {
            assert_eq!(
                TrigCondition::Percent81,
                TrigCondition::try_from(&23_u8).unwrap()
            )
        }
        #[test]
        fn perc87() {
            assert_eq!(
                TrigCondition::Percent87,
                TrigCondition::try_from(&24_u8).unwrap()
            )
        }
        #[test]
        fn perc91() {
            assert_eq!(
                TrigCondition::Percent91,
                TrigCondition::try_from(&25_u8).unwrap()
            )
        }
        #[test]
        fn perc94() {
            assert_eq!(
                TrigCondition::Percent94,
                TrigCondition::try_from(&26_u8).unwrap()
            )
        }
        #[test]
        fn perc96() {
            assert_eq!(
                TrigCondition::Percent96,
                TrigCondition::try_from(&27_u8).unwrap()
            )
        }
        #[test]
        fn perc98() {
            assert_eq!(
                TrigCondition::Percent98,
                TrigCondition::try_from(&28_u8).unwrap()
            )
        }
        #[test]
        fn perc99() {
            assert_eq!(
                TrigCondition::Percent99,
                TrigCondition::try_from(&29_u8).unwrap()
            )
        }
        #[test]
        fn pat_t1r2() {
            assert_eq!(
                TrigCondition::PatternT1R2,
                TrigCondition::try_from(&30_u8).unwrap()
            )
        }
        #[test]
        fn pat_t2r2() {
            assert_eq!(
                TrigCondition::PatternT2R2,
                TrigCondition::try_from(&31_u8).unwrap()
            )
        }
        #[test]
        fn pat_t1r3() {
            assert_eq!(
                TrigCondition::PatternT1R3,
                TrigCondition::try_from(&32_u8).unwrap()
            )
        }
        #[test]
        fn pat_t2r3() {
            assert_eq!(
                TrigCondition::PatternT2R3,
                TrigCondition::try_from(&33_u8).unwrap()
            )
        }
        #[test]
        fn pat_t3r3() {
            assert_eq!(
                TrigCondition::PatternT3R3,
                TrigCondition::try_from(&34_u8).unwrap()
            )
        }

        #[test]
        fn pat_t1r4() {
            assert_eq!(
                TrigCondition::PatternT1R4,
                TrigCondition::try_from(&35_u8).unwrap()
            )
        }
        #[test]
        fn pat_t2r4() {
            assert_eq!(
                TrigCondition::PatternT2R4,
                TrigCondition::try_from(&36_u8).unwrap()
            )
        }
        #[test]
        fn pat_t3r4() {
            assert_eq!(
                TrigCondition::PatternT3R4,
                TrigCondition::try_from(&37_u8).unwrap()
            )
        }
        #[test]
        fn pat_t4r4() {
            assert_eq!(
                TrigCondition::PatternT4R4,
                TrigCondition::try_from(&38_u8).unwrap()
            )
        }

        #[test]
        fn pat_t1r5() {
            assert_eq!(
                TrigCondition::PatternT1R5,
                TrigCondition::try_from(&39_u8).unwrap()
            )
        }
        #[test]
        fn pat_t2r5() {
            assert_eq!(
                TrigCondition::PatternT2R5,
                TrigCondition::try_from(&40_u8).unwrap()
            )
        }
        #[test]
        fn pat_t3r5() {
            assert_eq!(
                TrigCondition::PatternT3R5,
                TrigCondition::try_from(&41_u8).unwrap()
            )
        }
        #[test]
        fn pat_t4r5() {
            assert_eq!(
                TrigCondition::PatternT4R5,
                TrigCondition::try_from(&42_u8).unwrap()
            )
        }
        #[test]
        fn pat_t5r5() {
            assert_eq!(
                TrigCondition::PatternT5R5,
                TrigCondition::try_from(&43_u8).unwrap()
            )
        }

        #[test]
        fn pat_t1r6() {
            assert_eq!(
                TrigCondition::PatternT1R6,
                TrigCondition::try_from(&44_u8).unwrap()
            )
        }
        #[test]
        fn pat_t2r6() {
            assert_eq!(
                TrigCondition::PatternT2R6,
                TrigCondition::try_from(&45_u8).unwrap()
            )
        }
        #[test]
        fn pat_t3r6() {
            assert_eq!(
                TrigCondition::PatternT3R6,
                TrigCondition::try_from(&46_u8).unwrap()
            )
        }
        #[test]
        fn pat_t4r6() {
            assert_eq!(
                TrigCondition::PatternT4R6,
                TrigCondition::try_from(&47_u8).unwrap()
            )
        }
        #[test]
        fn pat_t5r6() {
            assert_eq!(
                TrigCondition::PatternT5R6,
                TrigCondition::try_from(&48_u8).unwrap()
            )
        }
        #[test]
        fn pat_t6r6() {
            assert_eq!(
                TrigCondition::PatternT6R6,
                TrigCondition::try_from(&49_u8).unwrap()
            )
        }

        #[test]
        fn pat_t1r7() {
            assert_eq!(
                TrigCondition::PatternT1R7,
                TrigCondition::try_from(&50_u8).unwrap()
            )
        }
        #[test]
        fn pat_t2r7() {
            assert_eq!(
                TrigCondition::PatternT2R7,
                TrigCondition::try_from(&51_u8).unwrap()
            )
        }
        #[test]
        fn pat_t3r7() {
            assert_eq!(
                TrigCondition::PatternT3R7,
                TrigCondition::try_from(&52_u8).unwrap()
            )
        }
        #[test]
        fn pat_t4r7() {
            assert_eq!(
                TrigCondition::PatternT4R7,
                TrigCondition::try_from(&53_u8).unwrap()
            )
        }
        #[test]
        fn pat_t5r7() {
            assert_eq!(
                TrigCondition::PatternT5R7,
                TrigCondition::try_from(&54_u8).unwrap()
            )
        }
        #[test]
        fn pat_t6r7() {
            assert_eq!(
                TrigCondition::PatternT6R7,
                TrigCondition::try_from(&55_u8).unwrap()
            )
        }
        #[test]
        fn pat_t7r7() {
            assert_eq!(
                TrigCondition::PatternT7R7,
                TrigCondition::try_from(&56_u8).unwrap()
            )
        }

        #[test]
        fn pat_t1r8() {
            assert_eq!(
                TrigCondition::PatternT1R8,
                TrigCondition::try_from(&57_u8).unwrap()
            )
        }
        #[test]
        fn pat_t2r8() {
            assert_eq!(
                TrigCondition::PatternT2R8,
                TrigCondition::try_from(&58_u8).unwrap()
            )
        }
        #[test]
        fn pat_t3r8() {
            assert_eq!(
                TrigCondition::PatternT3R8,
                TrigCondition::try_from(&59_u8).unwrap()
            )
        }
        #[test]
        fn pat_t4r8() {
            assert_eq!(
                TrigCondition::PatternT4R8,
                TrigCondition::try_from(&60_u8).unwrap()
            )
        }
        #[test]
        fn pat_t5r8() {
            assert_eq!(
                TrigCondition::PatternT5R8,
                TrigCondition::try_from(&61_u8).unwrap()
            )
        }
        #[test]
        fn pat_t6r8() {
            assert_eq!(
                TrigCondition::PatternT6R8,
                TrigCondition::try_from(&62_u8).unwrap()
            )
        }
        #[test]
        fn pat_t7r8() {
            assert_eq!(
                TrigCondition::PatternT7R8,
                TrigCondition::try_from(&63_u8).unwrap()
            )
        }
        #[test]
        fn pat_t8r8() {
            assert_eq!(
                TrigCondition::PatternT8R8,
                TrigCondition::try_from(&64_u8).unwrap()
            )
        }
    }
    mod get_value {
        use crate::settings::TrigCondition;

        #[test]
        fn none() {
            assert_eq!(TrigCondition::None as u8, 0)
        }
        #[test]
        fn fill() {
            assert_eq!(TrigCondition::Fill as u8, 1)
        }
        #[test]
        fn notfill() {
            assert_eq!(TrigCondition::NotFill as u8, 2)
        }
        #[test]
        fn pre() {
            assert_eq!(TrigCondition::Pre as u8, 3)
        }
        #[test]
        fn notpre() {
            assert_eq!(TrigCondition::NotPre as u8, 4)
        }
        #[test]
        fn nei() {
            assert_eq!(TrigCondition::Nei as u8, 5)
        }
        #[test]
        fn notnei() {
            assert_eq!(TrigCondition::NotNei as u8, 6)
        }
        #[test]
        fn first() {
            assert_eq!(TrigCondition::First as u8, 7)
        }
        #[test]
        fn notfirst() {
            assert_eq!(TrigCondition::NotFirst as u8, 8)
        }
        #[test]
        fn perc1() {
            assert_eq!(TrigCondition::Percent1 as u8, 9)
        }
        #[test]
        fn perc2() {
            assert_eq!(TrigCondition::Percent2 as u8, 10)
        }
        #[test]
        fn perc4() {
            assert_eq!(TrigCondition::Percent4 as u8, 11)
        }
        #[test]
        fn perc6() {
            assert_eq!(TrigCondition::Percent6 as u8, 12)
        }
        #[test]
        fn perc9() {
            assert_eq!(TrigCondition::Percent9 as u8, 13)
        }
        #[test]
        fn perc13() {
            assert_eq!(TrigCondition::Percent13 as u8, 14)
        }
        #[test]
        fn perc19() {
            assert_eq!(TrigCondition::Percent19 as u8, 15)
        }
        #[test]
        fn perc25() {
            assert_eq!(TrigCondition::Percent25 as u8, 16)
        }
        #[test]
        fn perc33() {
            assert_eq!(TrigCondition::Percent33 as u8, 17)
        }
        #[test]
        fn perc41() {
            assert_eq!(TrigCondition::Percent41 as u8, 18)
        }
        #[test]
        fn perc50() {
            assert_eq!(TrigCondition::Percent50 as u8, 19)
        }
        #[test]
        fn perc59() {
            assert_eq!(TrigCondition::Percent59 as u8, 20)
        }
        #[test]
        fn perc67() {
            assert_eq!(TrigCondition::Percent67 as u8, 21)
        }
        #[test]
        fn perc75() {
            assert_eq!(TrigCondition::Percent75 as u8, 22)
        }
        #[test]
        fn perc81() {
            assert_eq!(TrigCondition::Percent81 as u8, 23)
        }
        #[test]
        fn perc87() {
            assert_eq!(TrigCondition::Percent87 as u8, 24)
        }
        #[test]
        fn perc91() {
            assert_eq!(TrigCondition::Percent91 as u8, 25)
        }
        #[test]
        fn perc94() {
            assert_eq!(TrigCondition::Percent94 as u8, 26)
        }
        #[test]
        fn perc96() {
            assert_eq!(TrigCondition::Percent96 as u8, 27)
        }
        #[test]
        fn perc98() {
            assert_eq!(TrigCondition::Percent98 as u8, 28)
        }
        #[test]
        fn perc99() {
            assert_eq!(TrigCondition::Percent99 as u8, 29)
        }
        #[test]
        fn pat_t1r2() {
            assert_eq!(TrigCondition::PatternT1R2 as u8, 30)
        }
        #[test]
        fn pat_t2r2() {
            assert_eq!(TrigCondition::PatternT2R2 as u8, 31)
        }
        #[test]
        fn pat_t1r3() {
            assert_eq!(TrigCondition::PatternT1R3 as u8, 32)
        }
        #[test]
        fn pat_t2r3() {
            assert_eq!(TrigCondition::PatternT2R3 as u8, 33)
        }
        #[test]
        fn pat_t3r3() {
            assert_eq!(TrigCondition::PatternT3R3 as u8, 34)
        }

        #[test]
        fn pat_t1r4() {
            assert_eq!(TrigCondition::PatternT1R4 as u8, 35)
        }
        #[test]
        fn pat_t2r4() {
            assert_eq!(TrigCondition::PatternT2R4 as u8, 36)
        }
        #[test]
        fn pat_t3r4() {
            assert_eq!(TrigCondition::PatternT3R4 as u8, 37)
        }
        #[test]
        fn pat_t4r4() {
            assert_eq!(TrigCondition::PatternT4R4 as u8, 38)
        }

        #[test]
        fn pat_t1r5() {
            assert_eq!(TrigCondition::PatternT1R5 as u8, 39)
        }
        #[test]
        fn pat_t2r5() {
            assert_eq!(TrigCondition::PatternT2R5 as u8, 40)
        }
        #[test]
        fn pat_t3r5() {
            assert_eq!(TrigCondition::PatternT3R5 as u8, 41)
        }
        #[test]
        fn pat_t4r5() {
            assert_eq!(TrigCondition::PatternT4R5 as u8, 42)
        }
        #[test]
        fn pat_t5r5() {
            assert_eq!(TrigCondition::PatternT5R5 as u8, 43)
        }

        #[test]
        fn pat_t1r6() {
            assert_eq!(TrigCondition::PatternT1R6 as u8, 44)
        }
        #[test]
        fn pat_t2r6() {
            assert_eq!(TrigCondition::PatternT2R6 as u8, 45)
        }
        #[test]
        fn pat_t3r6() {
            assert_eq!(TrigCondition::PatternT3R6 as u8, 46)
        }
        #[test]
        fn pat_t4r6() {
            assert_eq!(TrigCondition::PatternT4R6 as u8, 47)
        }
        #[test]
        fn pat_t5r6() {
            assert_eq!(TrigCondition::PatternT5R6 as u8, 48)
        }
        #[test]
        fn pat_t6r6() {
            assert_eq!(TrigCondition::PatternT6R6 as u8, 49)
        }

        #[test]
        fn pat_t1r7() {
            assert_eq!(TrigCondition::PatternT1R7 as u8, 50)
        }
        #[test]
        fn pat_t2r7() {
            assert_eq!(TrigCondition::PatternT2R7 as u8, 51)
        }
        #[test]
        fn pat_t3r7() {
            assert_eq!(TrigCondition::PatternT3R7 as u8, 52)
        }
        #[test]
        fn pat_t4r7() {
            assert_eq!(TrigCondition::PatternT4R7 as u8, 53)
        }
        #[test]
        fn pat_t5r7() {
            assert_eq!(TrigCondition::PatternT5R7 as u8, 54)
        }
        #[test]
        fn pat_t6r7() {
            assert_eq!(TrigCondition::PatternT6R7 as u8, 55)
        }
        #[test]
        fn pat_t7r7() {
            assert_eq!(TrigCondition::PatternT7R7 as u8, 56)
        }

        #[test]
        fn pat_t1r8() {
            assert_eq!(TrigCondition::PatternT1R8 as u8, 57)
        }
        #[test]
        fn pat_t2r8() {
            assert_eq!(TrigCondition::PatternT2R8 as u8, 58)
        }
        #[test]
        fn pat_t3r8() {
            assert_eq!(TrigCondition::PatternT3R8 as u8, 59)
        }
        #[test]
        fn pat_t4r8() {
            assert_eq!(TrigCondition::PatternT4R8 as u8, 60)
        }
        #[test]
        fn pat_t5r8() {
            assert_eq!(TrigCondition::PatternT5R8 as u8, 61)
        }
        #[test]
        fn pat_t6r8() {
            assert_eq!(TrigCondition::PatternT6R8 as u8, 62)
        }
        #[test]
        fn pat_t7r8() {
            assert_eq!(TrigCondition::PatternT7R8 as u8, 63)
        }
        #[test]
        fn pat_t8r8() {
            assert_eq!(TrigCondition::PatternT8R8 as u8, 64)
        }
    }
}

/// MIDI Channel for Program Change settings in Project Settings Menu.
/// Used where both `Auto` and channel 1-16 options are available
/// (Project Menu -> Control -> Midi -> Sync).
/// See manual section 8.7.2 SYNC.
///
/// Values in `project.work`: `-1` = Auto, `0`-`15` = Channel 1-16.
#[derive(
    Copy,
    Clone,
    Debug,
    Default,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
    Serialize,
    Deserialize,
    AsMutDerive,
    AsRefDerive,
    IntoSigneds,
)]
#[repr(i8)]
pub enum ProgChMidiChannel {
    /// Auto MIDI Channel
    #[default]
    Auto = -1,
    /// MIDI CH 1
    One = 0,
    /// MIDI CH 2
    Two = 1,
    /// MIDI CH 3
    Three = 2,
    /// MIDI CH 4
    Four = 3,
    /// MIDI CH 5
    Five = 4,
    /// MIDI CH 6
    Six = 5,
    /// MIDI CH 7
    Seven = 6,
    /// MIDI CH 8
    Eight = 7,
    /// MIDI CH 9
    Nine = 8,
    /// MIDI CH 10
    Ten = 9,
    /// MIDI CH 11
    Eleven = 10,
    /// MIDI CH 12
    Twelve = 11,
    /// MIDI CH 13
    Thirteen = 12,
    /// MIDI CH 14
    Fourteen = 13,
    /// MIDI CH 15
    Fifteen = 14,
    /// MIDI CH 16
    Sixteen = 15,
}

#[enum_try_from_i32_to_signed_types]
impl TryFrom<i32> for ProgChMidiChannel {
    type Error = InvalidValueError;
    fn try_from(value: i32) -> Result<Self, Self::Error> {
        match value {
            -1 => Ok(Self::Auto),
            0 => Ok(Self::One),
            1 => Ok(Self::Two),
            2 => Ok(Self::Three),
            3 => Ok(Self::Four),
            4 => Ok(Self::Five),
            5 => Ok(Self::Six),
            6 => Ok(Self::Seven),
            7 => Ok(Self::Eight),
            8 => Ok(Self::Nine),
            9 => Ok(Self::Ten),
            10 => Ok(Self::Eleven),
            11 => Ok(Self::Twelve),
            12 => Ok(Self::Thirteen),
            13 => Ok(Self::Fourteen),
            14 => Ok(Self::Fifteen),
            15 => Ok(Self::Sixteen),
            _ => Err(InvalidValueError::ProgChMidiChannel),
        }
    }
}

#[cfg(test)]
#[allow(unused_imports)]
mod test_spec {

    mod value {
        use crate::settings::ProgChMidiChannel;

        #[test]
        fn test_auto() {
            assert_eq!(ProgChMidiChannel::Auto as i8, -1);
        }
        #[test]
        fn test_1() {
            assert_eq!(ProgChMidiChannel::One as i8, 0);
        }
        #[test]
        fn test_2() {
            assert_eq!(ProgChMidiChannel::Two as i8, 1);
        }
        #[test]
        fn test_3() {
            assert_eq!(ProgChMidiChannel::Three as i8, 2);
        }
        #[test]
        fn test_4() {
            assert_eq!(ProgChMidiChannel::Four as i8, 3);
        }
        #[test]
        fn test_5() {
            assert_eq!(ProgChMidiChannel::Five as i8, 4);
        }
        #[test]
        fn test_6() {
            assert_eq!(ProgChMidiChannel::Six as i8, 5);
        }
        #[test]
        fn test_7() {
            assert_eq!(ProgChMidiChannel::Seven as i8, 6);
        }
        #[test]
        fn test_8() {
            assert_eq!(ProgChMidiChannel::Eight as i8, 7);
        }
        #[test]
        fn test_9() {
            assert_eq!(ProgChMidiChannel::Nine as i8, 8);
        }
        #[test]
        fn test_10() {
            assert_eq!(ProgChMidiChannel::Ten as i8, 9);
        }
        #[test]
        fn test_11() {
            assert_eq!(ProgChMidiChannel::Eleven as i8, 10);
        }
        #[test]
        fn test_12() {
            assert_eq!(ProgChMidiChannel::Twelve as i8, 11);
        }
        #[test]
        fn test_13() {
            assert_eq!(ProgChMidiChannel::Thirteen as i8, 12);
        }
        #[test]
        fn test_14() {
            assert_eq!(ProgChMidiChannel::Fourteen as i8, 13);
        }
        #[test]
        fn test_15() {
            assert_eq!(ProgChMidiChannel::Fifteen as i8, 14);
        }
        #[test]
        fn test_16() {
            assert_eq!(ProgChMidiChannel::Sixteen as i8, 15);
        }
    }

    mod from_value {

        use crate::settings::ProgChMidiChannel;

        #[test]
        fn test_error_1() {
            assert!(ProgChMidiChannel::try_from(&100_i8).is_err());
        }
        #[test]
        fn test_auto() {
            assert_eq!(
                ProgChMidiChannel::Auto,
                ProgChMidiChannel::try_from(&-1_i8).unwrap()
            );
        }
        #[test]
        fn test_1() {
            assert_eq!(
                ProgChMidiChannel::One,
                ProgChMidiChannel::try_from(&0_i8).unwrap()
            );
        }
        #[test]
        fn test_2() {
            assert_eq!(
                ProgChMidiChannel::Two,
                ProgChMidiChannel::try_from(&1_i8).unwrap()
            );
        }
        #[test]
        fn test_3() {
            assert_eq!(
                ProgChMidiChannel::Three,
                ProgChMidiChannel::try_from(&2_i8).unwrap()
            );
        }
        #[test]
        fn test_4() {
            assert_eq!(
                ProgChMidiChannel::Four,
                ProgChMidiChannel::try_from(&3_i8).unwrap()
            );
        }
        #[test]
        fn test_5() {
            assert_eq!(
                ProgChMidiChannel::Five,
                ProgChMidiChannel::try_from(&4_i8).unwrap()
            );
        }
        #[test]
        fn test_6() {
            assert_eq!(
                ProgChMidiChannel::Six,
                ProgChMidiChannel::try_from(&5_i8).unwrap()
            );
        }
        #[test]
        fn test_7() {
            assert_eq!(
                ProgChMidiChannel::Seven,
                ProgChMidiChannel::try_from(&6_i8).unwrap()
            );
        }
        #[test]
        fn test_8() {
            assert_eq!(
                ProgChMidiChannel::Eight,
                ProgChMidiChannel::try_from(&7_i8).unwrap()
            );
        }
        #[test]
        fn test_9() {
            assert_eq!(
                ProgChMidiChannel::Nine,
                ProgChMidiChannel::try_from(&8_i8).unwrap()
            );
        }
        #[test]
        fn test_10() {
            assert_eq!(
                ProgChMidiChannel::Ten,
                ProgChMidiChannel::try_from(&9_i8).unwrap()
            );
        }
        #[test]
        fn test_11() {
            assert_eq!(
                ProgChMidiChannel::Eleven,
                ProgChMidiChannel::try_from(&10_i8).unwrap()
            );
        }
        #[test]
        fn test_12() {
            assert_eq!(
                ProgChMidiChannel::Twelve,
                ProgChMidiChannel::try_from(&11_i8).unwrap()
            );
        }
        #[test]
        fn test_13() {
            assert_eq!(
                ProgChMidiChannel::Thirteen,
                ProgChMidiChannel::try_from(&12_i8).unwrap()
            );
        }
        #[test]
        fn test_14() {
            assert_eq!(
                ProgChMidiChannel::Fourteen,
                ProgChMidiChannel::try_from(&13_i8).unwrap()
            );
        }
        #[test]
        fn test_15() {
            assert_eq!(
                ProgChMidiChannel::Fifteen,
                ProgChMidiChannel::try_from(&14_i8).unwrap()
            );
        }
        #[test]
        fn test_16() {
            assert_eq!(
                ProgChMidiChannel::Sixteen,
                ProgChMidiChannel::try_from(&15_i8).unwrap()
            );
        }
    }
}

/// Slot's machine type (cannot access flex samples for a static machine etc).
#[derive(
    Copy,
    Clone,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
    Serialize,
    Deserialize,
    AsMutDerive,
    AsRefDerive,
)]
pub enum SlotType {
    /// Static machine slot
    Static,
    /// Flex machine slot
    Flex,
}

impl SlotType {
    pub fn other(&self) -> Self {
        match self {
            Self::Static => Self::Flex,
            Self::Flex => Self::Static,
        }
    }
}

impl TryFrom<String> for SlotType {
    type Error = InvalidValueError;
    fn try_from(value: String) -> Result<Self, Self::Error> {
        match value.to_ascii_uppercase().as_str() {
            "STATIC" => Ok(SlotType::Static),
            "FLEX" => Ok(SlotType::Flex),
            _ => Err(InvalidValueError::SlotType),
        }
    }
}

impl TryFrom<&str> for SlotType {
    type Error = InvalidValueError;
    fn try_from(value: &str) -> Result<Self, Self::Error> {
        Self::try_from(value.to_string())
    }
}

impl Display for SlotType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let str = match self {
            SlotType::Static => "STATIC".to_string(),
            SlotType::Flex => "FLEX".to_string(),
        };
        write!(f, "{str}")
    }
}

impl From<SlotType> for String {
    fn from(value: SlotType) -> Self {
        value.to_string()
    }
}

#[cfg(test)]
mod slot_type {
    mod value {
        use crate::settings::SlotType;

        #[test]
        fn test_static() {
            assert_eq!(SlotType::Static.to_string(), "STATIC");
            assert_eq!(String::from(SlotType::Static), "STATIC");
        }
        #[test]
        fn test_flex() {
            assert_eq!(SlotType::Flex.to_string(), "FLEX");
            assert_eq!(String::from(SlotType::Flex), "FLEX");
        }
    }

    mod other {
        use crate::settings::SlotType;
        #[test]
        fn static_slot() {
            assert_eq!(SlotType::Static.other(), SlotType::Flex)
        }

        #[test]
        fn flex_slot() {
            assert_eq!(SlotType::Flex.other(), SlotType::Static)
        }
    }

    mod from_value {
        use crate::settings::SlotType;

        #[test]
        fn test_error() {
            assert!(SlotType::try_from("SOME INCORRECT STRING").is_err());
        }

        #[test]
        fn test_static_upper() {
            assert_eq!(SlotType::Static, SlotType::try_from("STATIC").unwrap(),);
        }

        #[test]
        fn test_static_lower() {
            assert_eq!(SlotType::Static, SlotType::try_from("static").unwrap(),);
        }

        #[test]
        fn test_flex_upper() {
            assert_eq!(SlotType::Flex, SlotType::try_from("FLEX").unwrap(),);
        }

        #[test]
        fn test_flex_lower() {
            assert_eq!(SlotType::Flex, SlotType::try_from("flex").unwrap(),);
        }
    }
}