11904027177

Committed 19 Nov 2024 12:33AM UTC coverage: 75.477% (+0.3%) from 75.174%

Build # 11904027177

Build Type

push

github

Committed by

web-flow

Commit Message

Move DateTimePattern into pattern module (#5834)

#1317

Also removes `NeoNeverMarker` and fixes #5689

Run Details

258 of 319 new or added lines in 6 files covered. (80.88%)

6967 existing lines in 278 files now uncovered.

54522 of 72237 relevant lines covered (75.48%)

655305.49 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

69.23

/utils/fixed_decimal/src/integer.rs

// 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 core::convert::TryFrom;
use core::fmt;

use core::str::FromStr;

use crate::FixedDecimal;
use crate::LimitError;
use crate::ParseError;

/// A [`FixedInteger`] is a [`FixedDecimal`] with no fractional part.
///
///
/// # Examples
///
/// ```
/// # use std::str::FromStr;
/// use fixed_decimal::FixedDecimal;
/// use fixed_decimal::FixedInteger;
/// use fixed_decimal::LimitError;
///
/// assert_eq!(
///     FixedDecimal::from(FixedInteger::from(5)),
///     FixedDecimal::from(5)
/// );
/// assert_eq!(
///     FixedInteger::try_from(FixedDecimal::from(5)),
///     Ok(FixedInteger::from(5))
/// );
/// assert_eq!(
///     FixedInteger::try_from(FixedDecimal::from_str("05").unwrap()),
///     Ok(FixedInteger::from_str("05").unwrap())
/// );
/// assert_eq!(
///     FixedInteger::try_from(FixedDecimal::from_str("5.0").unwrap()),
///     Err(LimitError)
/// );
/// ```
#[derive(Debug, Clone, PartialEq, Default)]
pub struct FixedInteger(FixedDecimal);

impl From<FixedInteger> for FixedDecimal {
    fn from(value: FixedInteger) -> Self {
        value.0
    }
}

macro_rules! impl_fixed_integer_from_integer_type {
    ($type:ident) => {
        impl From<$type> for FixedInteger {
            fn from(value: $type) -> Self {
                FixedInteger(FixedDecimal::from(value))
            }
        }
    };
}

impl_fixed_integer_from_integer_type!(isize);
impl_fixed_integer_from_integer_type!(i128);
impl_fixed_integer_from_integer_type!(i64);
impl_fixed_integer_from_integer_type!(i32);
impl_fixed_integer_from_integer_type!(i16);
impl_fixed_integer_from_integer_type!(i8);
impl_fixed_integer_from_integer_type!(usize);
impl_fixed_integer_from_integer_type!(u128);
impl_fixed_integer_from_integer_type!(u64);
impl_fixed_integer_from_integer_type!(u32);
impl_fixed_integer_from_integer_type!(u16);
impl_fixed_integer_from_integer_type!(u8);

impl writeable::Writeable for FixedInteger {
    fn write_to<W: fmt::Write + ?Sized>(&self, sink: &mut W) -> fmt::Result {
        self.0.write_to(sink)
    }
}

impl TryFrom<FixedDecimal> for FixedInteger {
    type Error = LimitError;
    fn try_from(value: FixedDecimal) -> Result<Self, Self::Error> {
        if value.magnitude_range().start() != &0 {
            Err(LimitError)
        } else {
            Ok(FixedInteger(value))
        }
    }
}

impl FixedInteger {
    #[inline]
    pub fn try_from_str(s: &str) -> Result<Self, ParseError> {
        Self::try_from_utf8(s.as_bytes())
    }

    pub fn try_from_utf8(code_units: &[u8]) -> Result<Self, ParseError> {
        FixedInteger::try_from(FixedDecimal::try_from_utf8(code_units)?)
            .map_err(|LimitError| ParseError::Limit)
    }
}

impl FromStr for FixedInteger {
    type Err = ParseError;
    #[inline]
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        Self::try_from_str(s)
    }
}

1	// This file is part of ICU4X. For terms of use, please see the file
2	// called LICENSE at the top level of the ICU4X source tree
3	// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
4
5	use core::convert::TryFrom;
6	use core::fmt;
7
8	use core::str::FromStr;
9
10	use crate::FixedDecimal;
11	use crate::LimitError;
12	use crate::ParseError;
13
14	/// A [`FixedInteger`] is a [`FixedDecimal`] with no fractional part.
15	///
16	///
17	/// # Examples
18	///
19	/// ```
20	/// # use std::str::FromStr;
21	/// use fixed_decimal::FixedDecimal;
22	/// use fixed_decimal::FixedInteger;
23	/// use fixed_decimal::LimitError;
24	///
25	/// assert_eq!(
26	/// FixedDecimal::from(FixedInteger::from(5)),
27	/// FixedDecimal::from(5)
28	/// );
29	/// assert_eq!(
30	/// FixedInteger::try_from(FixedDecimal::from(5)),
31	/// Ok(FixedInteger::from(5))
32	/// );
33	/// assert_eq!(
34	/// FixedInteger::try_from(FixedDecimal::from_str("05").unwrap()),
35	/// Ok(FixedInteger::from_str("05").unwrap())
36	/// );
37	/// assert_eq!(
38	/// FixedInteger::try_from(FixedDecimal::from_str("5.0").unwrap()),
39	/// Err(LimitError)
40	/// );
41	/// ```
42	#[derive(Debug, Clone, PartialEq, Default)]	×
UNCOV 43	pub struct FixedInteger(FixedDecimal);	×
44
45	impl From<FixedInteger> for FixedDecimal {
46	fn from(value: FixedInteger) -> Self {	1✔
47	value.0	1✔
48	}	1✔
49	}
50
51	macro_rules! impl_fixed_integer_from_integer_type {
52	($type:ident) => {
53	impl From<$type> for FixedInteger {
54	fn from(value: $type) -> Self {	3✔
55	FixedInteger(FixedDecimal::from(value))	3✔
56	}	3✔
57	}
58	};
59	}
60
61	impl_fixed_integer_from_integer_type!(isize);
62	impl_fixed_integer_from_integer_type!(i128);
63	impl_fixed_integer_from_integer_type!(i64);
64	impl_fixed_integer_from_integer_type!(i32);
65	impl_fixed_integer_from_integer_type!(i16);
66	impl_fixed_integer_from_integer_type!(i8);
67	impl_fixed_integer_from_integer_type!(usize);
68	impl_fixed_integer_from_integer_type!(u128);
69	impl_fixed_integer_from_integer_type!(u64);
70	impl_fixed_integer_from_integer_type!(u32);
71	impl_fixed_integer_from_integer_type!(u16);
72	impl_fixed_integer_from_integer_type!(u8);
73
74	impl writeable::Writeable for FixedInteger {
75	fn write_to<W: fmt::Write + ?Sized>(&self, sink: &mut W) -> fmt::Result {	6✔
76	self.0.write_to(sink)	6✔
77	}	6✔
78	}
79
80	impl TryFrom<FixedDecimal> for FixedInteger {
81	type Error = LimitError;
82	fn try_from(value: FixedDecimal) -> Result<Self, Self::Error> {	8✔
83	if value.magnitude_range().start() != &0 {	8✔
84	Err(LimitError)	2✔
85	} else {
86	Ok(FixedInteger(value))	6✔
87	}
88	}	8✔
89	}
90
91	impl FixedInteger {
92	#[inline]
UNCOV 93	pub fn try_from_str(s: &str) -> Result<Self, ParseError> {	×
UNCOV 94	Self::try_from_utf8(s.as_bytes())	×
UNCOV 95	}	×
96
97	pub fn try_from_utf8(code_units: &[u8]) -> Result<Self, ParseError> {	7✔
98	FixedInteger::try_from(FixedDecimal::try_from_utf8(code_units)?)	7✔
99	.map_err(\|LimitError\| ParseError::Limit)	1✔
100	}	7✔
101	}
102
103	impl FromStr for FixedInteger {
104	type Err = ParseError;
105	#[inline]
UNCOV 106	fn from_str(s: &str) -> Result<Self, Self::Err> {	×
UNCOV 107	Self::try_from_str(s)	×
UNCOV 108	}	×
109	}

zbraniecki / icu4x / 11904027177

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous