Skip to content

Commit ce51e65

Browse files
chansukepetrochenkov
chansuke
authored and
petrochenkov
committed
Separate libsyntax_ext module
1 parent f0c7857 commit ce51e65

File tree

3 files changed

+212
-215
lines changed

3 files changed

+212
-215
lines changed

‎src/libsyntax_ext/format_foreign.rs‎

Lines changed: 2 additions & 215 deletions
Original file line numberDiff line numberDiff line change
@@ -605,159 +605,7 @@ pub mod printf {
605605
}
606606

607607
#[cfg(test)]
608-
mod tests {
609-
use super::{
610-
Format as F,
611-
Num as N,
612-
Substitution as S,
613-
iter_subs,
614-
parse_next_substitution as pns,
615-
};
616-
617-
macro_rules! assert_eq_pnsat {
618-
($lhs:expr, $rhs:expr) => {
619-
assert_eq!(
620-
pns($lhs).and_then(|(s, _)| s.translate()),
621-
$rhs.map(<String as From<&str>>::from)
622-
)
623-
};
624-
}
625-
626-
#[test]
627-
fn test_escape() {
628-
assert_eq!(pns("has no escapes"), None);
629-
assert_eq!(pns("has no escapes, either %"), None);
630-
assert_eq!(pns("*so* has a %% escape"), Some((S::Escape," escape")));
631-
assert_eq!(pns("%% leading escape"), Some((S::Escape, " leading escape")));
632-
assert_eq!(pns("trailing escape %%"), Some((S::Escape, "")));
633-
}
634-
635-
#[test]
636-
fn test_parse() {
637-
macro_rules! assert_pns_eq_sub {
638-
($in_:expr, {
639-
$param:expr, $flags:expr,
640-
$width:expr, $prec:expr, $len:expr, $type_:expr,
641-
$pos:expr,
642-
}) => {
643-
assert_eq!(
644-
pns(concat!($in_, "!")),
645-
Some((
646-
S::Format(F {
647-
span: $in_,
648-
parameter: $param,
649-
flags: $flags,
650-
width: $width,
651-
precision: $prec,
652-
length: $len,
653-
type_: $type_,
654-
position: syntax_pos::InnerSpan::new($pos.0, $pos.1),
655-
}),
656-
"!"
657-
))
658-
)
659-
};
660-
}
661-
662-
assert_pns_eq_sub!("%!",
663-
{ None, "", None, None, None, "!", (0, 2), });
664-
assert_pns_eq_sub!("%c",
665-
{ None, "", None, None, None, "c", (0, 2), });
666-
assert_pns_eq_sub!("%s",
667-
{ None, "", None, None, None, "s", (0, 2), });
668-
assert_pns_eq_sub!("%06d",
669-
{ None, "0", Some(N::Num(6)), None, None, "d", (0, 4), });
670-
assert_pns_eq_sub!("%4.2f",
671-
{ None, "", Some(N::Num(4)), Some(N::Num(2)), None, "f", (0, 5), });
672-
assert_pns_eq_sub!("%#x",
673-
{ None, "#", None, None, None, "x", (0, 3), });
674-
assert_pns_eq_sub!("%-10s",
675-
{ None, "-", Some(N::Num(10)), None, None, "s", (0, 5), });
676-
assert_pns_eq_sub!("%*s",
677-
{ None, "", Some(N::Next), None, None, "s", (0, 3), });
678-
assert_pns_eq_sub!("%-10.*s",
679-
{ None, "-", Some(N::Num(10)), Some(N::Next), None, "s", (0, 7), });
680-
assert_pns_eq_sub!("%-*.*s",
681-
{ None, "-", Some(N::Next), Some(N::Next), None, "s", (0, 6), });
682-
assert_pns_eq_sub!("%.6i",
683-
{ None, "", None, Some(N::Num(6)), None, "i", (0, 4), });
684-
assert_pns_eq_sub!("%+i",
685-
{ None, "+", None, None, None, "i", (0, 3), });
686-
assert_pns_eq_sub!("%08X",
687-
{ None, "0", Some(N::Num(8)), None, None, "X", (0, 4), });
688-
assert_pns_eq_sub!("%lu",
689-
{ None, "", None, None, Some("l"), "u", (0, 3), });
690-
assert_pns_eq_sub!("%Iu",
691-
{ None, "", None, None, Some("I"), "u", (0, 3), });
692-
assert_pns_eq_sub!("%I32u",
693-
{ None, "", None, None, Some("I32"), "u", (0, 5), });
694-
assert_pns_eq_sub!("%I64u",
695-
{ None, "", None, None, Some("I64"), "u", (0, 5), });
696-
assert_pns_eq_sub!("%'d",
697-
{ None, "'", None, None, None, "d", (0, 3), });
698-
assert_pns_eq_sub!("%10s",
699-
{ None, "", Some(N::Num(10)), None, None, "s", (0, 4), });
700-
assert_pns_eq_sub!("%-10.10s",
701-
{ None, "-", Some(N::Num(10)), Some(N::Num(10)), None, "s", (0, 8), });
702-
assert_pns_eq_sub!("%1$d",
703-
{ Some(1), "", None, None, None, "d", (0, 4), });
704-
assert_pns_eq_sub!("%2$.*3$d",
705-
{ Some(2), "", None, Some(N::Arg(3)), None, "d", (0, 8), });
706-
assert_pns_eq_sub!("%1$*2$.*3$d",
707-
{ Some(1), "", Some(N::Arg(2)), Some(N::Arg(3)), None, "d", (0, 11), });
708-
assert_pns_eq_sub!("%-8ld",
709-
{ None, "-", Some(N::Num(8)), None, Some("l"), "d", (0, 5), });
710-
}
711-
712-
#[test]
713-
fn test_iter() {
714-
let s = "The %d'th word %% is: `%.*s` %!\n";
715-
let subs: Vec<_> = iter_subs(s, 0).map(|sub| sub.translate()).collect();
716-
assert_eq!(
717-
subs.iter().map(|ms| ms.as_ref().map(|s| &s[..])).collect::<Vec<_>>(),
718-
vec![Some("{}"), None, Some("{:.*}"), None]
719-
);
720-
}
721-
722-
/// Checks that the translations are what we expect.
723-
#[test]
724-
fn test_translation() {
725-
assert_eq_pnsat!("%c", Some("{}"));
726-
assert_eq_pnsat!("%d", Some("{}"));
727-
assert_eq_pnsat!("%u", Some("{}"));
728-
assert_eq_pnsat!("%x", Some("{:x}"));
729-
assert_eq_pnsat!("%X", Some("{:X}"));
730-
assert_eq_pnsat!("%e", Some("{:e}"));
731-
assert_eq_pnsat!("%E", Some("{:E}"));
732-
assert_eq_pnsat!("%f", Some("{}"));
733-
assert_eq_pnsat!("%g", Some("{:e}"));
734-
assert_eq_pnsat!("%G", Some("{:E}"));
735-
assert_eq_pnsat!("%s", Some("{}"));
736-
assert_eq_pnsat!("%p", Some("{:p}"));
737-
738-
assert_eq_pnsat!("%06d", Some("{:06}"));
739-
assert_eq_pnsat!("%4.2f", Some("{:4.2}"));
740-
assert_eq_pnsat!("%#x", Some("{:#x}"));
741-
assert_eq_pnsat!("%-10s", Some("{:<10}"));
742-
assert_eq_pnsat!("%*s", None);
743-
assert_eq_pnsat!("%-10.*s", Some("{:<10.*}"));
744-
assert_eq_pnsat!("%-*.*s", None);
745-
assert_eq_pnsat!("%.6i", Some("{:06}"));
746-
assert_eq_pnsat!("%+i", Some("{:+}"));
747-
assert_eq_pnsat!("%08X", Some("{:08X}"));
748-
assert_eq_pnsat!("%lu", Some("{}"));
749-
assert_eq_pnsat!("%Iu", Some("{}"));
750-
assert_eq_pnsat!("%I32u", Some("{}"));
751-
assert_eq_pnsat!("%I64u", Some("{}"));
752-
assert_eq_pnsat!("%'d", None);
753-
assert_eq_pnsat!("%10s", Some("{:>10}"));
754-
assert_eq_pnsat!("%-10.10s", Some("{:<10.10}"));
755-
assert_eq_pnsat!("%1$d", Some("{0}"));
756-
assert_eq_pnsat!("%2$.*3$d", Some("{1:02$}"));
757-
assert_eq_pnsat!("%1$*2$.*3$s", Some("{0:>1$.2$}"));
758-
assert_eq_pnsat!("%-8ld", Some("{:<8}"));
759-
}
760-
}
608+
mod tests;
761609
}
762610

763611
pub mod shell {
@@ -899,68 +747,7 @@ pub mod shell {
899747
}
900748

901749
#[cfg(test)]
902-
mod tests {
903-
use super::{
904-
Substitution as S,
905-
parse_next_substitution as pns,
906-
};
907-
908-
macro_rules! assert_eq_pnsat {
909-
($lhs:expr, $rhs:expr) => {
910-
assert_eq!(
911-
pns($lhs).and_then(|(f, _)| f.translate()),
912-
$rhs.map(<String as From<&str>>::from)
913-
)
914-
};
915-
}
916-
917-
#[test]
918-
fn test_escape() {
919-
assert_eq!(pns("has no escapes"), None);
920-
assert_eq!(pns("has no escapes, either $"), None);
921-
assert_eq!(pns("*so* has a $$ escape"), Some((S::Escape((11, 13)), " escape")));
922-
assert_eq!(pns("$$ leading escape"), Some((S::Escape((0, 2)), " leading escape")));
923-
assert_eq!(pns("trailing escape $$"), Some((S::Escape((16, 18)), "")));
924-
}
925-
926-
#[test]
927-
fn test_parse() {
928-
macro_rules! assert_pns_eq_sub {
929-
($in_:expr, $kind:ident($arg:expr, $pos:expr)) => {
930-
assert_eq!(pns(concat!($in_, "!")), Some((S::$kind($arg.into(), $pos), "!")))
931-
};
932-
}
933-
934-
assert_pns_eq_sub!("$0", Ordinal(0, (0, 2)));
935-
assert_pns_eq_sub!("$1", Ordinal(1, (0, 2)));
936-
assert_pns_eq_sub!("$9", Ordinal(9, (0, 2)));
937-
assert_pns_eq_sub!("$N", Name("N", (0, 2)));
938-
assert_pns_eq_sub!("$NAME", Name("NAME", (0, 5)));
939-
}
940-
941-
#[test]
942-
fn test_iter() {
943-
use super::iter_subs;
944-
let s = "The $0'th word $$ is: `$WORD` $!\n";
945-
let subs: Vec<_> = iter_subs(s, 0).map(|sub| sub.translate()).collect();
946-
assert_eq!(
947-
subs.iter().map(|ms| ms.as_ref().map(|s| &s[..])).collect::<Vec<_>>(),
948-
vec![Some("{0}"), None, Some("{WORD}")]
949-
);
950-
}
951-
952-
#[test]
953-
fn test_translation() {
954-
assert_eq_pnsat!("$0", Some("{0}"));
955-
assert_eq_pnsat!("$9", Some("{9}"));
956-
assert_eq_pnsat!("$1", Some("{1}"));
957-
assert_eq_pnsat!("$10", Some("{1}"));
958-
assert_eq_pnsat!("$stuff", Some("{stuff}"));
959-
assert_eq_pnsat!("$NAME", Some("{NAME}"));
960-
assert_eq_pnsat!("$PREFIX/bin", Some("{PREFIX}"));
961-
}
962-
963-
}
750+
mod tests;
964751
}
965752

966753
mod strcursor {

‎src/libsyntax_ext/format_foreign/printf/tests.rs‎

Lines changed: 151 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,151 @@
1+
use super::{
2+
Format as F,
3+
Num as N,
4+
Substitution as S,
5+
iter_subs,
6+
parse_next_substitution as pns,
7+
};
8+
9+
macro_rules! assert_eq_pnsat {
10+
($lhs:expr, $rhs:expr) => {
11+
assert_eq!(
12+
pns($lhs).and_then(|(s, _)| s.translate()),
13+
$rhs.map(<String as From<&str>>::from)
14+
)
15+
};
16+
}
17+
18+
#[test]
19+
fn test_escape() {
20+
assert_eq!(pns("has no escapes"), None);
21+
assert_eq!(pns("has no escapes, either %"), None);
22+
assert_eq!(pns("*so* has a %% escape"), Some((S::Escape," escape")));
23+
assert_eq!(pns("%% leading escape"), Some((S::Escape, " leading escape")));
24+
assert_eq!(pns("trailing escape %%"), Some((S::Escape, "")));
25+
}
26+
27+
#[test]
28+
fn test_parse() {
29+
macro_rules! assert_pns_eq_sub {
30+
($in_:expr, {
31+
$param:expr, $flags:expr,
32+
$width:expr, $prec:expr, $len:expr, $type_:expr,
33+
$pos:expr,
34+
}) => {
35+
assert_eq!(
36+
pns(concat!($in_, "!")),
37+
Some((
38+
S::Format(F {
39+
span: $in_,
40+
parameter: $param,
41+
flags: $flags,
42+
width: $width,
43+
precision: $prec,
44+
length: $len,
45+
type_: $type_,
46+
position: syntax_pos::InnerSpan::new($pos.0, $pos.1),
47+
}),
48+
"!"
49+
))
50+
)
51+
};
52+
}
53+
54+
assert_pns_eq_sub!("%!",
55+
{ None, "", None, None, None, "!", (0, 2), });
56+
assert_pns_eq_sub!("%c",
57+
{ None, "", None, None, None, "c", (0, 2), });
58+
assert_pns_eq_sub!("%s",
59+
{ None, "", None, None, None, "s", (0, 2), });
60+
assert_pns_eq_sub!("%06d",
61+
{ None, "0", Some(N::Num(6)), None, None, "d", (0, 4), });
62+
assert_pns_eq_sub!("%4.2f",
63+
{ None, "", Some(N::Num(4)), Some(N::Num(2)), None, "f", (0, 5), });
64+
assert_pns_eq_sub!("%#x",
65+
{ None, "#", None, None, None, "x", (0, 3), });
66+
assert_pns_eq_sub!("%-10s",
67+
{ None, "-", Some(N::Num(10)), None, None, "s", (0, 5), });
68+
assert_pns_eq_sub!("%*s",
69+
{ None, "", Some(N::Next), None, None, "s", (0, 3), });
70+
assert_pns_eq_sub!("%-10.*s",
71+
{ None, "-", Some(N::Num(10)), Some(N::Next), None, "s", (0, 7), });
72+
assert_pns_eq_sub!("%-*.*s",
73+
{ None, "-", Some(N::Next), Some(N::Next), None, "s", (0, 6), });
74+
assert_pns_eq_sub!("%.6i",
75+
{ None, "", None, Some(N::Num(6)), None, "i", (0, 4), });
76+
assert_pns_eq_sub!("%+i",
77+
{ None, "+", None, None, None, "i", (0, 3), });
78+
assert_pns_eq_sub!("%08X",
79+
{ None, "0", Some(N::Num(8)), None, None, "X", (0, 4), });
80+
assert_pns_eq_sub!("%lu",
81+
{ None, "", None, None, Some("l"), "u", (0, 3), });
82+
assert_pns_eq_sub!("%Iu",
83+
{ None, "", None, None, Some("I"), "u", (0, 3), });
84+
assert_pns_eq_sub!("%I32u",
85+
{ None, "", None, None, Some("I32"), "u", (0, 5), });
86+
assert_pns_eq_sub!("%I64u",
87+
{ None, "", None, None, Some("I64"), "u", (0, 5), });
88+
assert_pns_eq_sub!("%'d",
89+
{ None, "'", None, None, None, "d", (0, 3), });
90+
assert_pns_eq_sub!("%10s",
91+
{ None, "", Some(N::Num(10)), None, None, "s", (0, 4), });
92+
assert_pns_eq_sub!("%-10.10s",
93+
{ None, "-", Some(N::Num(10)), Some(N::Num(10)), None, "s", (0, 8), });
94+
assert_pns_eq_sub!("%1$d",
95+
{ Some(1), "", None, None, None, "d", (0, 4), });
96+
assert_pns_eq_sub!("%2$.*3$d",
97+
{ Some(2), "", None, Some(N::Arg(3)), None, "d", (0, 8), });
98+
assert_pns_eq_sub!("%1$*2$.*3$d",
99+
{ Some(1), "", Some(N::Arg(2)), Some(N::Arg(3)), None, "d", (0, 11), });
100+
assert_pns_eq_sub!("%-8ld",
101+
{ None, "-", Some(N::Num(8)), None, Some("l"), "d", (0, 5), });
102+
}
103+
104+
#[test]
105+
fn test_iter() {
106+
let s = "The %d'th word %% is: `%.*s` %!\n";
107+
let subs: Vec<_> = iter_subs(s, 0).map(|sub| sub.translate()).collect();
108+
assert_eq!(
109+
subs.iter().map(|ms| ms.as_ref().map(|s| &s[..])).collect::<Vec<_>>(),
110+
vec![Some("{}"), None, Some("{:.*}"), None]
111+
);
112+
}
113+
114+
/// Checks that the translations are what we expect.
115+
#[test]
116+
fn test_translation() {
117+
assert_eq_pnsat!("%c", Some("{}"));
118+
assert_eq_pnsat!("%d", Some("{}"));
119+
assert_eq_pnsat!("%u", Some("{}"));
120+
assert_eq_pnsat!("%x", Some("{:x}"));
121+
assert_eq_pnsat!("%X", Some("{:X}"));
122+
assert_eq_pnsat!("%e", Some("{:e}"));
123+
assert_eq_pnsat!("%E", Some("{:E}"));
124+
assert_eq_pnsat!("%f", Some("{}"));
125+
assert_eq_pnsat!("%g", Some("{:e}"));
126+
assert_eq_pnsat!("%G", Some("{:E}"));
127+
assert_eq_pnsat!("%s", Some("{}"));
128+
assert_eq_pnsat!("%p", Some("{:p}"));
129+
130+
assert_eq_pnsat!("%06d", Some("{:06}"));
131+
assert_eq_pnsat!("%4.2f", Some("{:4.2}"));
132+
assert_eq_pnsat!("%#x", Some("{:#x}"));
133+
assert_eq_pnsat!("%-10s", Some("{:<10}"));
134+
assert_eq_pnsat!("%*s", None);
135+
assert_eq_pnsat!("%-10.*s", Some("{:<10.*}"));
136+
assert_eq_pnsat!("%-*.*s", None);
137+
assert_eq_pnsat!("%.6i", Some("{:06}"));
138+
assert_eq_pnsat!("%+i", Some("{:+}"));
139+
assert_eq_pnsat!("%08X", Some("{:08X}"));
140+
assert_eq_pnsat!("%lu", Some("{}"));
141+
assert_eq_pnsat!("%Iu", Some("{}"));
142+
assert_eq_pnsat!("%I32u", Some("{}"));
143+
assert_eq_pnsat!("%I64u", Some("{}"));
144+
assert_eq_pnsat!("%'d", None);
145+
assert_eq_pnsat!("%10s", Some("{:>10}"));
146+
assert_eq_pnsat!("%-10.10s", Some("{:<10.10}"));
147+
assert_eq_pnsat!("%1$d", Some("{0}"));
148+
assert_eq_pnsat!("%2$.*3$d", Some("{1:02$}"));
149+
assert_eq_pnsat!("%1$*2$.*3$s", Some("{0:>1$.2$}"));
150+
assert_eq_pnsat!("%-8ld", Some("{:<8}"));
151+
}

0 commit comments

Comments
 (0)