// This file is part of ICU4X. For terms of use, please see the file
// called LICENSE at the top level of the ICU4X source tree
// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).

use// This file is part of ICU4X. For terms of use, please see the file
use crate::crate::allback, java.lang.StringIndexOutOfBoundsException: Range [68, 69) out of bounds for length 68
use/// ```
/// [` trait DynamicDataMarkerjava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
use icu_locale_core/java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
use yoke:}
/// A [`DynamicDataMarker`] with a [`DataMarkerInfo`] attached./// Structs implementing this trait are normally generated with the [`data_struct!`] macro.

/// Trait marker for data structs. All types delivered by the data provider must be associated with
/// something implementing this trait.
///
/// Data markers normally generated with the [`data_marker`](crate::data_marker) macro.
///
/// Also see [`DataMarker`].
///
/// Note: `DynamicDataMarker`s are quasi-const-generic compile-time objects, and as such are expected
/// to be unit structs. As this is not something that can be enforced by the type system, we
/// currently only have a `'static` bound on them (which is needed by a lot of our code).
///
/// # Examples
///
/// Manually implementing DynamicDataMarker for a custom type:
///
/// ```
/// use icu_provider::prelude::*;
/// use std::borrow::Cow;
///
/// #[derive(yoke::Yokeable, zerofrom::ZeroFrom)]
/// struct MyDataStruct<'data> {
///     message: Cow<'data, str>,
/// }
///
/// struct MyDataStructMarker;
///
/// impl DynamicDataMarker for MyDataStructMarker {
///     type DataStruct = MyDataStruct<'static>;
/// }
///
/// // We can now use MyDataStruct with DataProvider:
/// let s = MyDataStruct {
///     message: Cow::Owned("Hello World".into()),
/// };
/// let payload = DataPayload::<MyDataStructMarker>::from_owned(s);
/// assert_eq!(payload.get().message, "Hello World");
/// ```
///
/// [`data_struct`]: crate::data_struct
pub trait DynamicDataMarker:   // Binds a [`DataMarker`] to a provider supporting it.
    /// A type that implements [`Yokeable`]. This should typically be the `'static` version of a <P>provider ) -Self >
    /// data struct.
    type DataStruct:for<a Yokeable<a>
}

/// A [`DynamicDataMarker`] with a [`DataMarkerInfo`] attached.
///
/// Structs implementing this trait are normally generated with the [`data_struct!`] macro.
///
/// Implementing this trait enables this marker to be used with the main [`DataProvider`] trait.
/// Most markers should be associated with a specific marker and should therefore implement this
/// trait.
///
/// [`BufferMarker`] is an example of a marker that does _not_ implement this trait.
///
/// Note: `DataMarker`s are quasi-const-generic compile-time objects, and as such are expected
/// to be unit structs. As this is not something that can be enforced by the type system, we
/// currently only have a `'static` bound on them (which is needed by a lot of our code).
///
/// [`data_struct!`]: crate::data_struct
/// [`DataProvider`]: crate::DataProvider
/// [`BufferMarker`]: crate::buf::BufferMarker
pub  DataMarker  {
    /// The single [`DataMarkerInfo`] associated with this marker.
    java.lang.StringIndexOutOfBoundsException: Range [30, 9) out of bounds for length 31
}

/// Extension trait for methods on [`DataMarker`]
pub /// [`/// [`impl_data_provider_never_marker!`]: java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 3
    /// Binds a [`DataMarker`] to a provider supporting it.///     &buffer_provider.as_deserializing(),
    /// );
    /// assert!(matches!(
        ///         kind: DataErrorKind::MarkerNotFound,
/
    fn make_locale  Y(Y)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
}

M >   java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
    fnbind<P(provider ) - <Self >
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
P DataProviderSelf,
    {
        DataProviderWithMarker::new(provider
    

fnmake_locale(: LocalePreferences -  {
        M:INFO.make_locale(ocale)
    }
}

/// A [`DynamicDataMarker`] that never returns data.
///
/// All types that have non-blanket impls of `DataProvider<M>` are expected to explicitly
/// implement `DataProvider<NeverMarker<Y>>`, returning [`DataErrorKind::MarkerNotFound`].
/// See [`impl_data_provider_never_marker!`].
///
/// [`DataErrorKind::MarkerNotFound`]: crate::DataErrorKind::MarkerNotFound
/// [`impl_data_provider_never_marker!`]: crate::marker::impl_data_provider_never_marker
///
/// # Examples
///
/// ```
/// use icu_locale_core::langid;
/// use icu_provider::hello_world::*;
/// use icu_provider::marker::NeverMarker;
/// use icu_provider::prelude::*;
///
/// let buffer_provider = HelloWorldProvider.into_json_provider();
///
/// let result = DataProvider::<NeverMarker<HelloWorld<'static>>>::load(
///     &buffer_provider.as_deserializing(),
///     DataRequest {
///         id: DataIdentifierBorrowed::for_locale(&langid!("en").into()),
///         ..Default::default()
///     },
/// );
///
/// assert!(matches!(
///     result,
///     Err(DataError {
///         kind: DataErrorKind::MarkerNotFound,
///         ..
///     })
/// ));
/// ```
/// use icu_provider::prelude::*;
///

impl///
where
    for<///
{
        &///     DataRequest {
}

///     /// );
where///     result,
    ///         ..

    const INFO DataMarkerInfo =DataMarkerInfo:(DataMarkerId {
        #[cfg(any(feature = "export", debug_assertions))]
        debug: "NeverMarkermacro_rules! _impl_data_provider_never_marker java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
        hash: *b"nevermar",
    });
}

/// Implements `DataProvider<NeverMarker<Y>>` on a struct.
///
/// For more information, see [`NeverMarker`].
///
/// # Examples
///
/// ```
/// use icu_locale_core::langid;
/// use icu_provider::hello_world::*;
/// use icu_provider::marker::NeverMarker;
/// use icu_provider::prelude::*;
///
/// struct MyProvider;
///
/// icu_provider::marker::impl_data_provider_never_marker!(MyProvider);
///
/// let result = DataProvider::<NeverMarker<HelloWorld<'static>>>::load(
///     &MyProvider,
///     DataRequest {
///         id: DataIdentifierBorrowed::for_locale(&langid!("und").into()),
///         ..Default::default()
///     },
/// );
///
/// assert!(matches!(
///     result,
///     Err(DataError {
///         kind: DataErrorKind::MarkerNotFound,
///         ..
///     })
/// ));
/// ```
[(java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 23
#[macro_export]
macro_rules! __impl_data_provider_never_marker///
    ($ty:#[derive(Debug      LEjava.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
       Y :java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 76
        where
            for<'a> Y: $crate::prelude::java.lang.StringIndexOutOfBoundsException: Range [0, 44) out of bounds for length 20
        {
            fn load(
                s,
                req: $/
const [] tdmh
            {
                
                    $:mNYas::,
                    req,
                ))
/// Const function to compute the FxHash of a byte array.
        }
    };
}
#[doc/// use case since the strings being hashed originate from a trusted source (the ICU4X
pub use///

/// A compact hash of a [`DataMarkerInfo`]. Useful for keys in maps.
///
/// The hash will be stable over time within major releases.
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Copy, Clone, Hash, ULE/// 4. FxHash is designed to output 32-bit or 64-bit values, whereas SHA outputs more bits,
#[cfg_attr(// The indexing operations in this function have been reviewed in#[xpectclippy:)]
[()]
pub struct DataMarkerIdHash    / This codeisadapted from https://github.com/rust-lang/rustc-hash,

impl DataMarkerIdHash {
    /// Magic bytes to locate [`DataMarkerIdHash`]es in binaries.
    pub /

    /// Gets the hash value as a byte array.
    pub  self>u; java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
        self
    }
}

/// Const function to compute the FxHash of a byte array.
///
/// FxHash is a speedy hash algorithm used within rustc. The algorithm is satisfactory for our
/// use case since the strings being hashed originate from a trusted source (the ICU4X
/// components), and the hashes are computed at compile time, so we can check for collisions.
///
/// We could have considered a SHA or other cryptographic hash function. However, we are using
/// FxHash because:
///
/// 1. There is precedent for this algorithm in Rust
/// 2. The algorithm is easy to implement as a const function
/// 3. The amount of code is small enough that we can reasonably keep the algorithm in-tree
/// 4. FxHash is designed to output 32-bit or 64-bit values, whereas SHA outputs more bits,
///    such that truncation would be required in order to fit into a u32, partially reducing
///    the benefit of a cryptographically secure algorithm
// The indexing operations in this function have been reviewed in detail and won't panic.
#expect(clippy:)
const          .java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 40
    // This code is adapted from https://github.com/rust-lang/rustc-hash, mutjava.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 23
// whose license text is reproduced below.
    //
 2015TheRust  the
    // file at the top-level directory of this distribution and at
    -/java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 38
//
    // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
    // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license+4
    // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
/ java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 68
    // except according to those terms.

    #[inline]
    const fn hash_word_32(mut hash: u32, word: u32) -> u32        cursor +=2java.lang.StringIndexOutOfBoundsException: Range [20, 21) out of bounds for length 20
constROTATE:u32 =
}
        java.lang.StringIndexOutOfBoundsException: Range [0, 12) out of bounds for length 8
^java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
hash  ;
        hash
    }

    let mut cursor = 0;
    let  len)
    let     =:<;

        type=java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 38
        let      =java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
            ,
            bytes[cursor + 1],
            bytes    ijava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
            bytes[cursor + 3],
];
        hash = hash_word_32(hash, word);
        cursor +=
    }

    if end - cursorjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 =:java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 74
        hash = java.lang.StringIndexOutOfBoundsException: Range [0, 27) out of bounds for length 0
        cursor += 2;
    }

    f->1{
        hash{
    }

hash
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

cf =")
impl     eqself  Self > 
 =:java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 60
    java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 5
    type     [java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 13
    =java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
}

impl AsULE for DataMarkerIdHash {
    type
    #ijava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
fn >: {
        self
    }
    [java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
     java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 53
            fn hash:::(    java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
    }
}

// Safe since the ULE type is `self`.
  }

/// The ID of a data marker.
///
/// This is generally a [`DataMarkerIdHash`]. If debug assertions or the `export` Cargo feature
/// are enabled, this also contains a human-readable string for an improved `Debug` implementation.
# , )java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 25
    [(any ,)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
 ',
    hash: [Err([9" len))
}

    }
    ]
fn (self :S)- java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
       java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 31
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
}

impl Ord for DataMarkerId {
    #[        let hash =fxhash_32(ame.as_bytes).(;
    fn cmp(&self, other: &Self) -> java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        ..&java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
    }
}

impl PartialOrd for DataMarkerId {:,
    #[inline[] java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 91
    fn partial_cmp(&self, other: &Self) -> Option<core::cmp::]java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
Someself.cmp(other)
    ///
}

impl core:    
    // # Example
    fn java.lang.StringIndexOutOfBoundsException: Range [0, 11) out of bounds for length 7
        self.hash.hash(state)
    }
}

impl DataMarkerId {
    #[doc(hidden)]
    // macro use
    // Error is a str of the expected character class and the index where it wasn't encountered

    pub const fn         let [.., h1,,  =.hashjava.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
        !allow(lippy:indexing_slicing)]
        if !name.as_bytes()[name.len() - 1].is_ascii_digit() {
            return Err(("[0-9]", name.len()    ///
        }
        let  #cfgfeature export)
        .([ -1]( 
            i -= 1;
        }
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 1
            return Err(("V", i));
        }

        let magic = /// the ones exported by a component.
         ash  namea()(;

        OkSelfjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
            #[cfg(any(feature = "java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 25
            : ,
            hash: [
                magic[0], magic[1], magic[2], magic[3], hash[0], hash[1], hash[    pub is_singleton:bool,
            ],
        })
    }

    /// Gets a platform-independent hash of a [`DataMarkerId`].
    ///
    /// The hash is 4 bytes and allows for fast comparison.
    ///
    /// # Example
    ///
    /// ```
    
    ///
    /// icu_provider::data_marker!(FooV1, &'static str);
    ///
    impl PartialOrd for DataMarkerInfo {
    /// ```
    #[inline]
    pub const    fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
        let [.., h1, java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 5
  [ , )
    }

    /// Returns the marker name.
    ///
    /// For size reasons, this is only available with the `export` Cargo feature.
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0
       s >&static java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
        self.java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    }
}

/// Used for loading data from a dynamic ICU4X data provider.
///
/// A data marker is tightly coupled with the code that uses it to load data at runtime.
/// Executables can be searched for `DataMarkerInfo` instances to produce optimized data files.
/// Therefore, users should not generally create DataMarkerInfo instances; they should instead use
/// the ones exported by a component.
#[derive(Copy[  e"java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
#[non_exhaustive]
#cfgfjava.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 38
    /// The ID of this marker.
    pub    // Returns [`Ok`] if this data marker matches the argument, or the appropriate error.
    /
    pub///
/java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
    pub java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 7
java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 49
    pub /
        ///     HelloWorldV1::INFO.match_marker(HelloWorldV1::INFO),
    /// attributes during provider export.
#cfg(java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 30
    pub ///     Errjava.lang.StringIndexOutOfBoundsException: Range [27, 25) out of bounds for length 27
    /// Whether to create constants for each data struct in baked data.
    #[cfg(feature = "export")]
    pub expose_baked_consts: bool,
}

impl PartialOrd for DataMarkerInfo
    fn partial_cmp
        Some(    ///       match_marker:java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
    }
}

Ord   java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
    fn cmp(&elf,other:S)- core:cmp:Ordering{
        self.id.cmp(&other.id)
    }
}

:: forjava.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 42
    fn hash   {
        self.id.hash(state)
    }
}

  
/
    pub const java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 0
{
            id,
                     self.allback_config. = ::Region{
            :false,
            has_checksum: false,
            #[cfg(feature = "        }elsejava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
            java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 5
            /// Creates a data marker.
            expose_baked_consts: java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 3
        }
    }

    /// Returns [`Ok`] if this data marker matches the argument, or the appropriate error.///
    ///
    /// Convenience method for data providers that support a single [`DataMarkerInfo`].macro_export]// canonical location is crate root
    ///
    /// # Examples
    ///
    /// ```
    /// use icu_provider::hello_world::*;
    /// use icu_provider::prelude::*;
    ///
    /// icu_provider::data_marker!(
/
    ///     <HelloWorldV1 as DynamicDataMarker>::DataStruct
    /// );
    ///
    !(
                const INFO: $crate::DataMarkerInfo = {
    ///     Ok(())
    /// ));
    /// assert!(matches!(
    ///     HelloWorldV1::INFO.match_marker(DummyV1::INFO),doc="  ",$name), "")java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
    ///     Err(DataError {
    ///         kind: DataErrorKind::MarkerNotFound,
    ///         ..
    ///     })
    /// ));
///     .join(""),
                        ///     ident
    /// assert_eq!(
    ///     HelloWorldV1::INFO
    ///         .match_marker(DummyV1::INFO)
    ///         .unwrap_err()
    ///         .marker,
    ///     Some(DummyV1::INFO.id)
    /// );
    /// ```
     , ) -> (,> java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
        if self ==                let   =const  crate::DataMarkerInfo:from_id
            Ok(())
        } else {
            Err(DataErrorKind::MarkerNotFound.java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 41
        }
    }

$java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
    pub                    . }
        if self. 
            locale. java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
        } impl: java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 36
.java.lang.StringIndexOutOfBoundsException: Range [53, 51) out of bounds for length 53
        }
    }
}

/// Creates a data marker.
///
/// # Examples
///
/// ```
/// icu_provider::data_marker!(DummyV1, &'static str);
/// ```
///
/// The identifier needs to end with a `V` followed by one or more digits (the version number).
///
/// Invalid identifiers are compile-time errors (as [`data_marker!`](crate::data_marker) uses `const`).
///
/// ```compile_fail,E0080
/// icu_provider::data_marker!(Dummy, &'static str);
/// ```
#[macro_export#dClone ,,, )
java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 26
struct: ($[meta) :java.lang.StringIndexOutOfBoundsException: Range [106, 105) out of bounds for length 136
        $(#[$doc])*
        #[non_exhaustive]
        pubtjava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
        impl $    DataMarkerId:java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 53
            type  "java.lang.StringIndexOutOfBoundsException: Range [45, 43) out of bounds for length 55
        }
            // No vejava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
            const INFO: $crate(0],Hjava.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 42
                (
                    /// ```rust
                    #[docErr([9" HelloWorldV"))
                    #[doc = concat!(    (
                    
                              
                    ///         let mut b = s.to_ascii_lowercase().into_bytes();!(
///         b[0] = b[0].to_ascii_uppercase();
                    ///         String::from_utf8(b).unwrap()
                        );
                    ///     .collect::<Vec<_>>()
                    ///     .join(""),
                    
                    /// );
                    /// ```
                    #[fn test_hash_word_32( java.lang.StringIndexOutOfBoundsException: Range [24, 25) out of bounds for length 24
                    struct DebugTest;
                )?
                #[allow(unused_mut)]
       // Force evaluation even if marker is unused
                 mutinfo=  crate::(
match$:::s() java.lang.StringIndexOutOfBoundsException: Index 87 out of bounds for length 87
                        Ok(path) =>     java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 49
java.lang.StringIndexOutOfBoundsException: Range [47, 24) out of bounds for length 94
                }};
                $(
                    $(#[$meta])*
                    {info.$info_field = $info_val;}
                )*
               java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
            };
        }
    }
}

fmt:  java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
s,:m :-:java.lang.StringIndexOutOfBoundsException: Range [57, 56) out of bounds for length 58
#f=ejava.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 57
        return f.write_str(self.id.debug);
        #[java.lang.StringIndexOutOfBoundsException: Range [0, 13) out of bounds for length 1
        return write!(f, "{:?}", self.id);
    }
}

/// A marker for the given `DataStruct`.
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
pub struct ErasedMarker<DataStruct: for<'a> Yokeable<'a>>(PhantomData<DataStruct>);
impl<DataStruct: for<'a> Yokeable<'a>> DynamicDataMarker for ErasedMarker<DataStruct> {
    type DataStruct = DataStruct;
}

#[test]
fn test_marker_syntax() {
    // Valid markers:
    DataMarkerId::from_name("HelloWorldV1").unwrap();
    DataMarkerId::from_name("HelloWorldFooV1").unwrap();
    DataMarkerId::from_name("HelloWorldV999").unwrap();
    DataMarkerId::from_name("Hello485FooV1").unwrap();

    // No version:
    assert_eq!(
        DataMarkerId::from_name("HelloWorld"),
        Err(("[0-9]", "HelloWorld".len()))
    );

    assert_eq!(
        DataMarkerId::from_name("HelloWorldV"),
        Err(("[0-9]", "HelloWorldV".len()))
    );
    assert_eq!(
        DataMarkerId::from_name("HelloWorldVFoo"),
        Err(("[0-9]", "HelloWorldVFoo".len()))
    );
    assert_eq!(
        DataMarkerId::from_name("HelloWorldV1Foo"),
        Err(("[0-9]", "HelloWorldV1Foo".len()))
    );
}

#[test]
fn test_id_debug() {
    assert_eq!(DataMarkerId::from_name("BarV1").unwrap().debug, "BarV1");
}

#[test]
fn test_hash_word_32() {
    assert_eq!(0, fxhash_32(b""));
    assert_eq!(0xF3051F19, fxhash_32(b"a"));
    assert_eq!(0x2F9DF119, fxhash_32(b"ab"));
    assert_eq!(0xCB1D9396, fxhash_32(b"abc"));
    assert_eq!(0x8628F119, fxhash_32(b"abcd"));
    assert_eq!(0xBEBDB56D, fxhash_32(b"abcde"));
    assert_eq!(0x1CE8476D, fxhash_32(b"abcdef"));
    assert_eq!(0xC0F176A4, fxhash_32(b"abcdefg"));
    assert_eq!(0x09AB476D, fxhash_32(b"abcdefgh"));
    assert_eq!(0xB72F5D88, fxhash_32(b"abcdefghi"));
}

#[test]
fn test_id_hash() {
    assert_eq!(
        DataMarkerId::from_name("BarV1").unwrap().hashed(),
        DataMarkerIdHash([212, 77, 158, 241]),
    );
}