ot_tools_io/

banks.rs

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

//! Types for `bank??.*` binary data files.

use crate::parts::Parts;
use crate::patterns::PatternArray;

use crate::{
    Defaults, HasChecksumField, HasFileVersionField, HasHeaderField, OctatrackFileIO,
    OtToolsIoError,
};
use ot_tools_io_derive::{ArrayDefaults, BoxedBigArrayDefaults, IntegrityChecks, IsDefaultCheck};
use serde::{Deserialize, Serialize};
use serde_big_array::{Array, BigArray};
use std::array::from_fn;

/// Bank header data.
/// ```text
/// FORM....DPS1BANK.....
/// 46 4f 52 4d 00 00 00 00 44 50 53 31 42 41 4e 4b 00 00 00 00 00
/// [70 79 82 77 0 0 0 0 68 80 83 49 66 65 78 75 0 0 0 0 0]
/// ```
pub const BANK_HEADER: [u8; 21] = [
    70, 79, 82, 77, 0, 0, 0, 0, 68, 80, 83, 49, 66, 65, 78, 75, 0, 0, 0, 0, 0,
];

/// Current/supported version of bank files.
pub const BANK_FILE_VERSION: u8 = 23;

const BANK_DEFAULT_CHECKSUM: u16 = 48022;

/// An Octatrack Bank. Contains data related to Parts and Patterns.
#[derive(
    Debug,
    Serialize,
    Deserialize,
    Clone,
    PartialEq,
    ArrayDefaults,
    BoxedBigArrayDefaults,
    IsDefaultCheck,
    IntegrityChecks,
)]
pub struct BankFile {
    /// Misc header data for Banks.
    /// Always follows the same format.
    #[serde(with = "BigArray")]
    pub header: [u8; 21],

    pub datatype_version: u8,

    /// Pattern data for a Bank.
    // note -- stack overflow if trying to use #[serde(with = "BigArray")]
    pub patterns: PatternArray,

    /// All part data for this bank, includes currently unsaved and previously saved state
    pub parts: Parts,

    /// Indicates which parts have previously saved state available for reloading.
    #[serde(with = "BigArray")]
    pub parts_saved_state: [u8; 4],

    /// Bit mask indicating which parts are currently in an edited state.
    /// ```text
    /// parts
    /// 1 2 3 4 | mask
    /// --------|------
    /// - - - - | 0
    /// x - - - | 1
    /// - x - - | 2
    /// - - x - | 4
    /// - - - x | 8
    /// --------|------
    /// x x - - | 3
    /// x - x - | 5
    /// - x x - | 6
    /// x x x - | 7
    /// x - - x | 9
    /// - x - x | 10
    /// x x - x | 11
    /// - - x x | 12
    /// - x x x | 14
    /// x x x x | 15
    /// ```
    pub parts_edited_bitmask: u8,

    /// Names for each Part within the Bank.
    /// Maximum 7 character length.
    #[serde(with = "BigArray")]
    pub part_names: [[u8; 7]; 4],

    /// checksum bytes
    pub checksum: u16,
}

/// Default Part names (ONE, TWO, THREE, FOUR) converted to u8 for ease of use.
const DEFAULT_PART_NAMES: [[u8; 7]; 4] = [
    [0x4f, 0x4e, 0x45, 0x00, 0x00, 0x00, 0x00], // "ONE",
    [0x54, 0x57, 0x4f, 0x00, 0x00, 0x00, 0x00], // "TWO",
    [0x54, 0x48, 0x52, 0x45, 0x45, 0x00, 0x00], // "THREE",
    [0x46, 0x4f, 0x55, 0x52, 0x00, 0x00, 0x00], // "FOUR",
];

impl OctatrackFileIO for BankFile {
    fn encode(&self) -> Result<Vec<u8>, OtToolsIoError>
    where
        Self: Serialize,
    {
        let mut chkd = self.clone();
        chkd.checksum = self.calculate_checksum()?;
        let bytes = bincode::serialize(&chkd)?;
        Ok(bytes)
    }
}

impl Default for BankFile {
    fn default() -> Self {
        Self {
            header: BANK_HEADER,
            datatype_version: BANK_FILE_VERSION,
            patterns: PatternArray::default(),
            parts: Parts::default(),
            parts_saved_state: from_fn(|_| 0),
            parts_edited_bitmask: 0,
            part_names: DEFAULT_PART_NAMES,
            // WARN: mutated during encode! do not calculate checksum in this
            // method until i've refactored `get_checksum` to not use Bank::default()
            // (end up with a never ending recursive loop of calling default)
            // TODO: Hardcoded
            checksum: BANK_DEFAULT_CHECKSUM,
        }
    }
}

#[cfg(test)]
mod decode {
    use crate::{
        read_bin_file, test_utils::get_blank_proj_dirpath, BankFile, OctatrackFileIO,
        OtToolsIoError,
    };
    #[test]
    fn valid() -> Result<(), OtToolsIoError> {
        let path = get_blank_proj_dirpath().join("bank01.work");
        let bytes = read_bin_file(&path)?;
        let s = BankFile::decode(&bytes)?;
        assert_eq!(s, BankFile::default());
        Ok(())
    }
}

#[cfg(test)]
mod encode {
    use crate::{
        read_bin_file, test_utils::get_blank_proj_dirpath, BankFile, OctatrackFileIO,
        OtToolsIoError,
    };
    #[test]
    fn valid() -> Result<(), OtToolsIoError> {
        let path = get_blank_proj_dirpath().join("bank01.work");
        let bytes = read_bin_file(&path)?;
        let b = BankFile::default().encode()?;
        assert_eq!(b, bytes);
        Ok(())
    }
}

impl HasChecksumField for BankFile {
    fn calculate_checksum(&self) -> Result<u16, OtToolsIoError> {
        // TODO: factor out the default bank byte values subtraction
        //       this shouldn't be needed as we add the values back later
        //       (post `wrapping_mul(256)`)

        let bytes = bincode::serialize(&self)?;
        let bytes_no_header_no_chk = &bytes[16..bytes.len() - 2];

        let default_bytes = &bincode::serialize(&BankFile::default())?;
        let default_bytes_no_header_no_chk = &default_bytes[16..bytes.len() - 2];

        // subtract default byte value from actual byte value, sum differences
        // note: this means `byte_diffs` can become negative
        let mut byte_diffs: i64 = 0;
        for (byte, def_byte) in bytes_no_header_no_chk
            .iter()
            .zip(default_bytes_no_header_no_chk)
        {
            byte_diffs += (*byte as i64) - (*def_byte as i64);
        }

        // Underflow wrapping correction.
        //
        // this was a code submission originally from
        // https://gitlab.com/dijksterhuis/ot-tools-io/-/merge_requests/1
        //
        // It's aiming to fix the nasty off-by-one error for certain bank files.
        // The result is off-by-256, but that's only because of the
        // `bytes_diffs.wrapping_mul(256)` at the end of the method.
        //
        // the code submission was generated using an AI/LLM aget thingy system.
        // i am not 100% convinced this is the correct algorithm for bank
        // check-summing ... but it is working for a large number of test cases.
        //
        // so we're running with it for now.
        //
        // TODO: this is a really weird algo. doesn't look right to me...
        // why would 105 be used on both sides of the branch condition check?
        // at the very least i suspect the default bank checksum value elements
        // to the algo can be factored out somehow
        //
        // it's basically doing ... if 'wrapping remainder' + 'default' >= 'default'
        // then -1 from 'wrapping remainder' ... ?
        //
        // BUT only when byte_diff is negative ... i.e. the byte values are
        // cumulatively less than the default values ...

        if byte_diffs < 0 {
            let div = byte_diffs.div_euclid(u16::MAX as i64);
            let rem = byte_diffs.rem_euclid(u16::MAX as i64);
            // original: => 256 - (default_checksum % 256)
            //           => 256 - (48022 % 256)
            //           => 105
            let adjustment = if (rem + 105) / 256 >= 105 {
                -div - 1
            } else {
                -div
            };
            byte_diffs += adjustment;
            // dbg!(
            //     byte_diffs - adj,
            //     byte_diffs,
            //     div,
            //     rem,
            //     (rem + 105) / 256,
            //     adj
            // );
        }

        // everything is multiplied by 256
        // add on default bank checksum (we subtracted the values to get
        // accurate `byte_diffs`)
        // then get wrapping remainder and casting to u16

        // TODO: see above about factoring default stuff out

        let check = byte_diffs
            .wrapping_mul(256)
            .wrapping_add(BANK_DEFAULT_CHECKSUM as i64);
        let modded = check.rem_euclid(u16::MAX as i64);
        dbg!(check, modded);
        Ok(modded as u16)
    }

    fn check_checksum(&self) -> Result<bool, OtToolsIoError> {
        Ok(self.checksum == self.calculate_checksum()?)
    }
}

#[cfg(test)]
mod checksum_field {
    use crate::{BankFile, HasChecksumField, OtToolsIoError};
    #[test]
    fn valid() -> Result<(), OtToolsIoError> {
        let mut x = BankFile::default();
        x.checksum = x.calculate_checksum()?;
        assert!(x.check_checksum()?);
        Ok(())
    }

    #[test]
    fn invalid() -> Result<(), OtToolsIoError> {
        let x = BankFile {
            checksum: u16::MAX,
            ..Default::default()
        };
        assert!(!x.check_checksum()?);
        Ok(())
    }

    mod files {
        use crate::test_utils::{get_bank_dirpath, get_blank_proj_dirpath};
        use crate::{BankFile, HasChecksumField, OctatrackFileIO, OtToolsIoError};
        use std::path::Path;

        fn helper_test_chksum(fp: &Path) -> Result<(u16, u16), OtToolsIoError> {
            let valid = BankFile::from_data_file(fp)?;
            let mut test = valid.clone();
            test.checksum = 0;
            let chk = test.calculate_checksum()?;
            Ok((chk, valid.checksum))
        }

        #[allow(clippy::field_reassign_with_default)]
        #[test]
        fn default_method() -> Result<(), OtToolsIoError> {
            let (_, valid) = helper_test_chksum(&get_blank_proj_dirpath().join("bank01.work"))?;
            let mut x = BankFile::default();
            x.checksum = 0;
            let test = x.calculate_checksum()?;
            assert_eq!(test, valid);
            Ok(())
        }

        #[test]
        fn default_bank1_file() -> Result<(), OtToolsIoError> {
            let (test, valid) = helper_test_chksum(&get_blank_proj_dirpath().join("bank01.work"))?;
            assert_eq!(test, valid);
            Ok(())
        }

        #[test]
        fn default_bank2_file() -> Result<(), OtToolsIoError> {
            let (test, valid) = helper_test_chksum(&get_blank_proj_dirpath().join("bank02.work"))?;
            assert_eq!(test, valid);
            Ok(())
        }

        #[test]
        fn one_scene_zero_val() -> Result<(), OtToolsIoError> {
            // start value incremented by 127 (max) and len incremented by 127 (max) on the machine
            let (test, valid) = helper_test_chksum(
                &get_bank_dirpath()
                    .join("checksum")
                    .join("scene1-atrack1-lfo-dep1-zero.work"),
            )?;
            assert_eq!(test, valid);
            Ok(())
        }

        #[test]
        fn one_scene_127_val() -> Result<(), OtToolsIoError> {
            // start value incremented by 127 (max) and len incremented by 127 (max) on the machine
            let (test, valid) = helper_test_chksum(
                &get_bank_dirpath()
                    .join("checksum")
                    .join("scene1-atrack1-lfo-dep1-127.work"),
            )?;
            assert_eq!(test, valid);
            Ok(())
        }

        #[test]
        fn scene_params_decr_lots() -> Result<(), OtToolsIoError> {
            // all scenes have assignments on the LFO parameters for track 1 - sets everything tp 0
            let (test, valid) = helper_test_chksum(
                &get_bank_dirpath()
                    .join("checksum")
                    .join("all-scenes-lfo-params-zeroed.work"),
            )?;
            assert_eq!(test, valid);
            Ok(())
        }

        mod static_strt_only {
            use super::helper_test_chksum;
            use crate::test_utils::get_bank_dirpath;
            use crate::OtToolsIoError;

            #[test]
            fn static_strt_1() -> Result<(), OtToolsIoError> {
                // start value incremented by one on the machine
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("static-strt-1.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn static_strt_2() -> Result<(), OtToolsIoError> {
                // start value incremented by two on the machine
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("static-strt-2.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn static_strt_10() -> Result<(), OtToolsIoError> {
                // start value incremented by ten on the machine
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("static-strt-10.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            // off by one -- this is why we have so many of these test examples
            #[test]
            fn static_strt_127() -> Result<(), OtToolsIoError> {
                // start value incremented by 127 (max) on the machine
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("static-strt-127.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn static_strt_126() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("static-strt-126.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn static_strt_125() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("static-strt-125.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn static_strt_124() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("static-strt-124.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn static_strt_123() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("static-strt-123.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn static_strt_122() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("static-strt-122.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn static_strt_121() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("static-strt-121.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn static_strt_120() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("static-strt-120.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn static_strt_119() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("static-strt-119.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn static_strt_118() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("static-strt-118.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn static_strt_117() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("static-strt-117.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn static_strt_116() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("static-strt-116.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn static_strt_115() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("static-strt-115.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn static_strt_114() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("static-strt-114.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn static_strt_113() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("static-strt-113.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn static_strt_112() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("static-strt-112.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn static_strt_111() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("static-strt-111.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn static_strt_71() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("static-strt-71.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn static_strt_70() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("static-strt-70.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn static_strt_69() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("static-strt-69.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn static_strt_68() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("static-strt-68.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn static_strt_67() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("static-strt-67.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn static_strt_66() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("static-strt-66.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn static_strt_65() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("static-strt-65.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn static_strt_64() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("static-strt-64.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn static_strt_63() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("static-strt-63.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn static_strt_62() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("static-strt-62.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn static_strt_61() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("static-strt-61.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn static_strt_60() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("static-strt-60.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn static_strt_59() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("static-strt-59.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn static_strt_58() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("static-strt-58.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn static_strt_57() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("static-strt-57.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn static_strt_56() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("static-strt-56.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }
        }

        mod static_strt_mult {
            use super::helper_test_chksum;
            use crate::test_utils::get_bank_dirpath;
            use crate::OtToolsIoError;

            #[test]
            fn static_strt_127_len_128() -> Result<(), OtToolsIoError> {
                // start value incremented by 127 (max) and len incremented by 127 (max) on the machine
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("static-strt-127-len-128.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn static_strt_67_len_67() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("static-strt-67-len-67.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn static_strt_67_len_68() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("static-strt-67-len-68.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn static_strt_68_len_68() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("static-strt-68-len-68.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn static_strt_67_len_66() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("static-strt-67-len-66.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn static_strt_66_len_66() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("static-strt-66-len-66.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn static_strt_32_len_32() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("static-strt-32-len-32.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn static_strt_32_len_33() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("static-strt-32-len-33.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn static_strt_33_len_33() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("static-strt-33-len-33.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn static_strt_32_len_31() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("static-strt-32-len-31.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn static_strt_31_len_31() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("static-strt-31-len-31.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn static_strt_67_len_67_rtrg_68() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("static-strt-67-len-67-rtrg-68.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn static_strt_67_len_68_rtrg_68() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("static-strt-67-len-68-rtrg-68.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn static_strt_67_len_69_rtrg_68() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("static-strt-67-len-69-rtrg-68.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn static_strt_67_len_69_rtrg_69() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("static-strt-67-len-69-rtrg-69.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn static_strt_67_len_69_rtrg_67() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("static-strt-67-len-69-rtrg-67.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn static_strt_67_len_67_rtrg_67() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("static-strt-67-len-67-rtrg-67.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }
        }

        mod flex_strt {
            use super::helper_test_chksum;
            use crate::test_utils::get_bank_dirpath;
            use crate::OtToolsIoError;

            #[test]
            fn flex_strt_126() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("flex-strt-126.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn flex_strt_125() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("flex-strt-125.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn flex_strt_124() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("flex-strt-124.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn flex_strt_123() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("flex-strt-123.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn flex_strt_122() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("flex-strt-122.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn flex_strt_121() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("flex-strt-121.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn flex_strt_120() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("flex-strt-120.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn flex_strt_119() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("flex-strt-119.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn flex_strt_118() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("flex-strt-118.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn flex_strt_117() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("flex-strt-117.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn flex_strt_116() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("flex-strt-116.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn flex_strt_115() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("flex-strt-115.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn flex_strt_114() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("flex-strt-114.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn flex_strt_113() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("flex-strt-113.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn flex_strt_112() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("flex-strt-112.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn flex_strt_111() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("flex-strt-111.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }
        }

        mod track_parameters {
            use super::helper_test_chksum;
            use crate::test_utils::get_bank_dirpath;
            use crate::OtToolsIoError;

            #[test]
            fn track_params_attack_127() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("tparams-attack-127.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn track_params_hold_0() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("tparams-hold-0.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn track_params_release_0() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("tparams-rel-0.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }
            #[test]
            fn track_params_vol_neg64() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("tparams-vol-neg64.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn track_params_vol_pos63() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("tparams-vol-pos63.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn track_params_balance_neg64() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("tparams-bal-neg64.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn track_params_balance_pos63() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("tparams-bal-pos63.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn track_params_lfo1_spd_0() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("tparams-lfo1-spd-0.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn track_params_lfo1_spd_127() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("tparams-lfo1-spd-127.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn track_params_lfo1_amt_64() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("tparams-lfo1-amt-64.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn track_params_lfo1_amt_127() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("tparams-lfo1-amt-127.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn track_params_fx1_filter_base_127() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("tparams-fx1-filt-base-127.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn track_params_fx1_filter_width_0() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("tparams-fx1-filt-wid-0.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn track_params_fx1_filter_q_127() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("tparams-fx1-filt-q-127.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn track_params_fx1_filter_depth_neg64() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("tparams-fx1-filt-dep-neg64.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn track_params_fx1_filter_depth_pos63() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("tparams-fx1-filt-dep-pos63.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn track_params_fx2_delay_snd_127() -> Result<(), OtToolsIoError> {
                // start value incremented by 127 (max) and len incremented by 127 (max) on the machine
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("atrack1-delay-snd-127.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }
        }

        mod lfo_designer {
            use super::helper_test_chksum;
            use crate::test_utils::get_bank_dirpath;
            use crate::OtToolsIoError;

            #[test]
            fn lfo_design_atr1_step1_pos64() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("lfo-design-step1-64.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn lfo_design_atr1_step1_pos127() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("lfo-design-step1-127.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn lfo_design_atr1_step1_neg64() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("lfo-design-step1-neg64.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn lfo_design_atr1_step1_neg128() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("lfo-design-step1-neg128.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }

            #[test]
            fn lfo_design_atr1_randomised() -> Result<(), OtToolsIoError> {
                let (test, valid) = helper_test_chksum(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("lfo-design-randomised.work"),
                )?;
                assert_eq!(test, valid);
                Ok(())
            }
        }
        mod real_bank_files {
            use super::helper_test_chksum;
            use crate::test_utils::get_bank_dirpath;
            use crate::OtToolsIoError;

            mod romant_delete {
                use super::*;
                #[test]
                fn b01() -> Result<(), OtToolsIoError> {
                    let (test, valid) = helper_test_chksum(
                        &get_bank_dirpath()
                            .join("checksum")
                            .join("romant-delete-b01.work"),
                    )?;
                    assert_eq!(test, valid);
                    Ok(())
                }
                #[test]
                fn b02() -> Result<(), OtToolsIoError> {
                    let (test, valid) = helper_test_chksum(
                        &get_bank_dirpath()
                            .join("checksum")
                            .join("romant-delete-b02.work"),
                    )?;
                    assert_eq!(test, valid);
                    Ok(())
                }
                #[test]
                fn b03() -> Result<(), OtToolsIoError> {
                    let (test, valid) = helper_test_chksum(
                        &get_bank_dirpath()
                            .join("checksum")
                            .join("romant-delete-b03.work"),
                    )?;
                    assert_eq!(test, valid);
                    Ok(())
                }
                #[test]
                fn b04() -> Result<(), OtToolsIoError> {
                    let (test, valid) = helper_test_chksum(
                        &get_bank_dirpath()
                            .join("checksum")
                            .join("romant-delete-b04.work"),
                    )?;
                    assert_eq!(test, valid);
                    Ok(())
                }
                #[test]
                fn b05() -> Result<(), OtToolsIoError> {
                    let (test, valid) = helper_test_chksum(
                        &get_bank_dirpath()
                            .join("checksum")
                            .join("romant-delete-b05.work"),
                    )?;
                    assert_eq!(test, valid);
                    Ok(())
                }
                #[test]
                fn b06() -> Result<(), OtToolsIoError> {
                    let (test, valid) = helper_test_chksum(
                        &get_bank_dirpath()
                            .join("checksum")
                            .join("romant-delete-b06.work"),
                    )?;
                    assert_eq!(test, valid);
                    Ok(())
                }
                #[test]
                fn b07() -> Result<(), OtToolsIoError> {
                    let (test, valid) = helper_test_chksum(
                        &get_bank_dirpath()
                            .join("checksum")
                            .join("romant-delete-b07.work"),
                    )?;
                    assert_eq!(test, valid);
                    Ok(())
                }
                #[test]
                fn b08() -> Result<(), OtToolsIoError> {
                    let (test, valid) = helper_test_chksum(
                        &get_bank_dirpath()
                            .join("checksum")
                            .join("romant-delete-b08.work"),
                    )?;
                    assert_eq!(test, valid);
                    Ok(())
                }
                #[test]
                fn b09() -> Result<(), OtToolsIoError> {
                    let (test, valid) = helper_test_chksum(
                        &get_bank_dirpath()
                            .join("checksum")
                            .join("romant-delete-b09.work"),
                    )?;
                    assert_eq!(test, valid);
                    Ok(())
                }
                #[test]
                fn b10() -> Result<(), OtToolsIoError> {
                    let (test, valid) = helper_test_chksum(
                        &get_bank_dirpath()
                            .join("checksum")
                            .join("romant-delete-b10.work"),
                    )?;
                    assert_eq!(test, valid);
                    Ok(())
                }
                #[test]
                fn b11() -> Result<(), OtToolsIoError> {
                    let (test, valid) = helper_test_chksum(
                        &get_bank_dirpath()
                            .join("checksum")
                            .join("romant-delete-b11.work"),
                    )?;
                    assert_eq!(test, valid);
                    Ok(())
                }
                #[test]
                fn b12() -> Result<(), OtToolsIoError> {
                    let (test, valid) = helper_test_chksum(
                        &get_bank_dirpath()
                            .join("checksum")
                            .join("romant-delete-b12.work"),
                    )?;
                    assert_eq!(test, valid);
                    Ok(())
                }
                #[test]
                fn b13() -> Result<(), OtToolsIoError> {
                    let (test, valid) = helper_test_chksum(
                        &get_bank_dirpath()
                            .join("checksum")
                            .join("romant-delete-b13.work"),
                    )?;
                    assert_eq!(test, valid);
                    Ok(())
                }
                #[test]
                fn b14() -> Result<(), OtToolsIoError> {
                    let (test, valid) = helper_test_chksum(
                        &get_bank_dirpath()
                            .join("checksum")
                            .join("romant-delete-b14.work"),
                    )?;
                    assert_eq!(test, valid);
                    Ok(())
                }
                #[test]
                fn b15() -> Result<(), OtToolsIoError> {
                    let (test, valid) = helper_test_chksum(
                        &get_bank_dirpath()
                            .join("checksum")
                            .join("romant-delete-b15.work"),
                    )?;
                    assert_eq!(test, valid);
                    Ok(())
                }
                #[test]
                fn b16() -> Result<(), OtToolsIoError> {
                    let (test, valid) = helper_test_chksum(
                        &get_bank_dirpath()
                            .join("checksum")
                            .join("romant-delete-b16.work"),
                    )?;
                    assert_eq!(test, valid);
                    Ok(())
                }
            }
        }
        mod real_projects {
            use super::helper_test_chksum;
            use crate::test_utils::get_bank_dirpath;
            use crate::OtToolsIoError;
            use std::path::{Path, PathBuf};

            fn bank_fpaths_from_dirpath(dirpath: &Path) -> Result<Vec<PathBuf>, OtToolsIoError> {
                let mut v: Vec<PathBuf> = Vec::new();
                for i in 1..=16 {
                    let fname = format!["bank{i:0>2}.work"].to_string();
                    v.push(dirpath.join(fname).to_path_buf());
                }
                Ok(v)
            }

            fn tests_helper(dirname: &str) -> Result<(), OtToolsIoError> {
                let fpaths = bank_fpaths_from_dirpath(
                    &get_bank_dirpath()
                        .join("checksum")
                        .join("live")
                        .join(dirname),
                )?;

                let mut results: Vec<bool> = Vec::new();

                for test_fpath in fpaths {
                    let (test, valid) = helper_test_chksum(&test_fpath)?;

                    if test != valid {
                        println!("Bad file: {test_fpath:?}");
                    }
                    results.push(test == valid);
                }
                println!(
                    "\n----------------\n{:?} incorrect file checksums",
                    results.iter().filter(|x| !*(*x)).count()
                );
                assert!(results.iter().all(|x| *x));
                Ok(())
            }

            #[test]
            fn romant_delete() -> Result<(), OtToolsIoError> {
                tests_helper("ROMANT_DELETING")
            }

            #[test]
            fn iamacameratheworldis() -> Result<(), OtToolsIoError> {
                tests_helper("1704Iamacameratheworldis")
            }

            #[test]
            fn a2() -> Result<(), OtToolsIoError> {
                tests_helper("A2")
            }

            #[test]
            fn aaaadrafts0() -> Result<(), OtToolsIoError> {
                tests_helper("AAAADRAFTS0")
            }

            #[test]
            fn aaaaplay() -> Result<(), OtToolsIoError> {
                tests_helper("AAAAplay")
            }

            #[test]
            fn aaambient() -> Result<(), OtToolsIoError> {
                tests_helper("AAAMBIENT")
            }

            #[test]
            fn aaasafespaces() -> Result<(), OtToolsIoError> {
                tests_helper("AAAsafespaces")
            }

            #[test]
            fn aacrackhead() -> Result<(), OtToolsIoError> {
                tests_helper("AACRACKHEAD")
            }

            #[test]
            fn aadrums() -> Result<(), OtToolsIoError> {
                tests_helper("AADRUMS")
            }

            #[test]
            fn album5() -> Result<(), OtToolsIoError> {
                tests_helper("ALBUM5")
            }

            #[test]
            fn ammbbb() -> Result<(), OtToolsIoError> {
                tests_helper("AMMBBB")
            }

            #[test]
            fn empty() -> Result<(), OtToolsIoError> {
                tests_helper("EMPTY")
            }

            #[test]
            fn filmsoundings() -> Result<(), OtToolsIoError> {
                tests_helper("FILMSOUNDINGS")
            }

            #[test]
            fn gorgieflat() -> Result<(), OtToolsIoError> {
                tests_helper("GORGIEFLAT1")
            }

            #[test]
            fn gorgiehow2lose() -> Result<(), OtToolsIoError> {
                tests_helper("gorgiehow2lose")
            }

            #[test]
            fn gorgierecordsin() -> Result<(), OtToolsIoError> {
                tests_helper("gorgierecordsin")
            }

            #[test]
            fn gorgiettl() -> Result<(), OtToolsIoError> {
                tests_helper("gorgiettl")
            }

            // # cringe
            #[test]
            fn iwishyouwouldletmeloveyou() -> Result<(), OtToolsIoError> {
                tests_helper("IWishYouWouldLetMeLoveYou")
            }

            #[test]
            fn jigg() -> Result<(), OtToolsIoError> {
                tests_helper("jigg")
            }

            #[test]
            fn livetechno60days() -> Result<(), OtToolsIoError> {
                tests_helper("LIVETECHNO60DAYS")
            }

            #[test]
            fn nawwww() -> Result<(), OtToolsIoError> {
                tests_helper("NAWWWWW")
            }

            #[test]
            fn nones() -> Result<(), OtToolsIoError> {
                tests_helper("NINES")
            }

            #[test]
            fn no_recording() -> Result<(), OtToolsIoError> {
                tests_helper("NO_RECORDING")
            }

            #[test]
            fn other() -> Result<(), OtToolsIoError> {
                tests_helper("OTHER")
            }

            #[test]
            fn recovery() -> Result<(), OtToolsIoError> {
                tests_helper("recovery")
            }

            #[test]
            fn singleintricatepieces() -> Result<(), OtToolsIoError> {
                tests_helper("singleintricatepieces")
            }

            #[test]
            fn songs_back() -> Result<(), OtToolsIoError> {
                tests_helper("SONGS_BAck")
            }

            #[test]
            fn songs() -> Result<(), OtToolsIoError> {
                tests_helper("SONGS")
            }

            #[test]
            fn stop_talkingnlet_me_dance() -> Result<(), OtToolsIoError> {
                tests_helper("stop_talkingnlet_me_dance")
            }

            #[test]
            fn syshalt() -> Result<(), OtToolsIoError> {
                tests_helper("sys-halt")
            }

            #[test]
            fn systems() -> Result<(), OtToolsIoError> {
                tests_helper("SYSTEMS")
            }

            #[test]
            fn teka() -> Result<(), OtToolsIoError> {
                tests_helper("TEkA")
            }
        }
    }
}

impl HasHeaderField for BankFile {
    fn check_header(&self) -> Result<bool, OtToolsIoError> {
        Ok(self.header == BANK_HEADER)
    }
}

#[cfg(test)]
mod header_field {
    use crate::{BankFile, HasHeaderField, OtToolsIoError};
    #[test]
    fn valid() -> Result<(), OtToolsIoError> {
        assert!(BankFile::default().check_header()?);
        Ok(())
    }

    #[test]
    fn invalid() -> Result<(), OtToolsIoError> {
        let mut mutated = BankFile::default();
        mutated.header[0] = 0x00;
        mutated.header[20] = 111;
        assert!(!mutated.check_header()?);
        Ok(())
    }
}

impl HasFileVersionField for BankFile {
    fn check_file_version(&self) -> Result<bool, OtToolsIoError> {
        Ok(BANK_FILE_VERSION == self.datatype_version)
    }
}

#[cfg(test)]
mod file_version_field {
    use crate::{BankFile, HasFileVersionField, OtToolsIoError};
    #[test]
    fn valid() -> Result<(), OtToolsIoError> {
        assert!(BankFile::default().check_file_version()?);
        Ok(())
    }

    #[test]
    fn invalid() -> Result<(), OtToolsIoError> {
        let x = BankFile {
            datatype_version: 0,
            ..BankFile::default()
        };
        assert!(!x.check_file_version()?);
        Ok(())
    }
}