From 5e20a29b4fdc8a2d442d1093681b396dcb4b816b Mon Sep 17 00:00:00 2001 From: Robin Krahl Date: Tue, 7 Jan 2020 11:18:04 +0000 Subject: Add structopt dependency in version 0.3.7 This patch series replaces argparse with structopt in the argument handling code. As a first step, we need structopt as a dependency. Import subrepo structopt/:structopt at efbdda4753592e27bc430fb01f7b9650b2f3174d Import subrepo bitflags/:bitflags at 30668016aca6bd3b02c766e8347e0b4080d4c296 Import subrepo clap/:clap at 784524f7eb193e35f81082cc69454c8c21b948f7 Import subrepo heck/:heck at 093d56fbf001e1506e56dbfa38631d99b1066df1 Import subrepo proc-macro-error/:proc-macro-error at 6c4cfe79a622c5de8ae68557993542be46eacae2 Import subrepo proc-macro2/:proc-macro2 at d5d48eddca4566e5438e8a2cbed4a74e049544de Import subrepo quote/:quote at 727436c6c137b20f0f34dde5d8fda2679b9747ad Import subrepo rustversion/:rustversion at 0c5663313516263059ce9059ef81fc7a1cf655ca Import subrepo syn-mid/:syn-mid at 5d3d85414a9e6674e1857ec22a87b96e04a6851a Import subrepo syn/:syn at e87c27e87f6f4ef8919d0372bdb056d53ef0d8f3 Import subrepo textwrap/:textwrap at abcd618beae3f74841032aa5b53c1086b0a57ca2 Import subrepo unicode-segmentation/:unicode-segmentation at 637c9874c4fe0c205ff27787faf150a40295c6c3 Import subrepo unicode-width/:unicode-width at 3033826f8bf05e82724140a981d5941e48fce393 Import subrepo unicode-xid/:unicode-xid at 4baae9fffb156ba229665b972a9cd5991787ceb7 --- unicode-segmentation/src/test.rs | 197 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 197 insertions(+) create mode 100644 unicode-segmentation/src/test.rs (limited to 'unicode-segmentation/src/test.rs') diff --git a/unicode-segmentation/src/test.rs b/unicode-segmentation/src/test.rs new file mode 100644 index 0000000..75b77c5 --- /dev/null +++ b/unicode-segmentation/src/test.rs @@ -0,0 +1,197 @@ +// Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +use super::UnicodeSegmentation; + +use std::prelude::v1::*; + +#[test] +fn test_graphemes() { + use testdata::{TEST_SAME, TEST_DIFF}; + + pub const EXTRA_DIFF: &'static [(&'static str, + &'static [&'static str], + &'static [&'static str])] = &[ + // Official test suite doesn't include two Prepend chars between two other chars. + ("\u{20}\u{600}\u{600}\u{20}", + &["\u{20}", "\u{600}\u{600}\u{20}"], + &["\u{20}", "\u{600}", "\u{600}", "\u{20}"]), + + // Test for Prepend followed by two Any chars + ("\u{600}\u{20}\u{20}", + &["\u{600}\u{20}", "\u{20}"], + &["\u{600}", "\u{20}", "\u{20}"]), + ]; + + pub const EXTRA_SAME: &'static [(&'static str, &'static [&'static str])] = &[ + // family emoji (more than two emoji joined by ZWJ) + ("\u{1f468}\u{200d}\u{1f467}\u{200d}\u{1f466}", + &["\u{1f468}\u{200d}\u{1f467}\u{200d}\u{1f466}"]), + // cartwheel emoji followed by two fitzpatrick skin tone modifiers + // (test case from issue #19) + ("\u{1F938}\u{1F3FE}\u{1F3FE}", + &["\u{1F938}\u{1F3FE}\u{1F3FE}"]), + ]; + + for &(s, g) in TEST_SAME.iter().chain(EXTRA_SAME) { + // test forward iterator + assert!(UnicodeSegmentation::graphemes(s, true).eq(g.iter().cloned())); + assert!(UnicodeSegmentation::graphemes(s, false).eq(g.iter().cloned())); + + // test reverse iterator + assert!(UnicodeSegmentation::graphemes(s, true).rev().eq(g.iter().rev().cloned())); + assert!(UnicodeSegmentation::graphemes(s, false).rev().eq(g.iter().rev().cloned())); + } + + for &(s, gt, gf) in TEST_DIFF.iter().chain(EXTRA_DIFF) { + // test forward iterator + assert!(UnicodeSegmentation::graphemes(s, true).eq(gt.iter().cloned())); + assert!(UnicodeSegmentation::graphemes(s, false).eq(gf.iter().cloned())); + + // test reverse iterator + assert!(UnicodeSegmentation::graphemes(s, true).rev().eq(gt.iter().rev().cloned())); + assert!(UnicodeSegmentation::graphemes(s, false).rev().eq(gf.iter().rev().cloned())); + } + + // test the indices iterators + let s = "a̐éö̲\r\n"; + let gr_inds = UnicodeSegmentation::grapheme_indices(s, true).collect::>(); + let b: &[_] = &[(0, "a̐"), (3, "é"), (6, "ö̲"), (11, "\r\n")]; + assert_eq!(gr_inds, b); + let gr_inds = UnicodeSegmentation::grapheme_indices(s, true).rev().collect::>(); + let b: &[_] = &[(11, "\r\n"), (6, "ö̲"), (3, "é"), (0, "a̐")]; + assert_eq!(gr_inds, b); + let mut gr_inds_iter = UnicodeSegmentation::grapheme_indices(s, true); + { + let gr_inds = gr_inds_iter.by_ref(); + let e1 = gr_inds.size_hint(); + assert_eq!(e1, (1, Some(13))); + let c = gr_inds.count(); + assert_eq!(c, 4); + } + let e2 = gr_inds_iter.size_hint(); + assert_eq!(e2, (0, Some(0))); + + // make sure the reverse iterator does the right thing with "\n" at beginning of string + let s = "\n\r\n\r"; + let gr = UnicodeSegmentation::graphemes(s, true).rev().collect::>(); + let b: &[_] = &["\r", "\r\n", "\n"]; + assert_eq!(gr, b); +} + +#[test] +fn test_words() { + use testdata::TEST_WORD; + + // Unicode's official tests don't really test longer chains of flag emoji + // TODO This could be improved with more tests like flag emoji with interspersed Extend chars and ZWJ + const EXTRA_TESTS: &'static [(&'static str, &'static [&'static str])] = &[ + ("🇦🇫🇦🇽🇦🇱🇩🇿🇦🇸🇦🇩🇦🇴", &["🇦🇫", "🇦🇽", "🇦🇱", "🇩🇿", "🇦🇸", "🇦🇩", "🇦🇴"]), + ("🇦🇫🇦🇽🇦🇱🇩🇿🇦🇸🇦🇩🇦", &["🇦🇫", "🇦🇽", "🇦🇱", "🇩🇿", "🇦🇸", "🇦🇩", "🇦"]), + ("🇦a🇫🇦🇽a🇦🇱🇩🇿🇦🇸🇦🇩🇦", &["🇦", "a", "🇫🇦", "🇽", "a", "🇦🇱", "🇩🇿", "🇦🇸", "🇦🇩", "🇦"]), + ("\u{1f468}\u{200d}\u{1f468}\u{200d}\u{1f466}", &["\u{1f468}\u{200d}\u{1f468}\u{200d}\u{1f466}"]), + ("😌👎🏼", &["😌", "👎🏼"]), + // perhaps wrong, spaces should not be included? + ("hello world", &["hello", " ", "world"]), + ("🇨🇦🇨🇭🇿🇲🇿 hi", &["🇨🇦", "🇨🇭", "🇿🇲", "🇿", " ", "hi"]), + ]; + for &(s, w) in TEST_WORD.iter().chain(EXTRA_TESTS.iter()) { + macro_rules! assert_ { + ($test:expr, $exp:expr, $name:expr) => { + // collect into vector for better diagnostics in failure case + let testing = $test.collect::>(); + let expected = $exp.collect::>(); + assert_eq!(testing, expected, "{} test for testcase ({:?}, {:?}) failed.", $name, s, w) + } + } + // test forward iterator + assert_!(s.split_word_bounds(), + w.iter().cloned(), + "Forward word boundaries"); + + // test reverse iterator + assert_!(s.split_word_bounds().rev(), + w.iter().rev().cloned(), + "Reverse word boundaries"); + + // generate offsets from word string lengths + let mut indices = vec![0]; + for i in w.iter().cloned().map(|s| s.len()).scan(0, |t, n| { *t += n; Some(*t) }) { + indices.push(i); + } + indices.pop(); + let indices = indices; + + // test forward indices iterator + assert_!(s.split_word_bound_indices().map(|(l,_)| l), + indices.iter().cloned(), + "Forward word indices"); + + // test backward indices iterator + assert_!(s.split_word_bound_indices().rev().map(|(l,_)| l), + indices.iter().rev().cloned(), + "Reverse word indices"); + } +} + + +#[test] +fn test_sentences() { + use testdata::TEST_SENTENCE; + + for &(s, w) in TEST_SENTENCE.iter() { + macro_rules! assert_ { + ($test:expr, $exp:expr, $name:expr) => { + // collect into vector for better diagnostics in failure case + let testing = $test.collect::>(); + let expected = $exp.collect::>(); + assert_eq!(testing, expected, "{} test for testcase ({:?}, {:?}) failed.", $name, s, w) + } + } + + assert_!(s.split_sentence_bounds(), + w.iter().cloned(), + "Forward sentence boundaries"); + } +} + +quickcheck! { + fn quickcheck_forward_reverse_graphemes_extended(s: String) -> bool { + let a = s.graphemes(true).collect::>(); + let mut b = s.graphemes(true).rev().collect::>(); + b.reverse(); + a == b + } + + fn quickcheck_forward_reverse_graphemes_legacy(s: String) -> bool { + let a = s.graphemes(false).collect::>(); + let mut b = s.graphemes(false).rev().collect::>(); + b.reverse(); + a == b + } + + fn quickcheck_join_graphemes(s: String) -> bool { + let a = s.graphemes(true).collect::(); + let b = s.graphemes(false).collect::(); + a == s && b == s + } + + fn quickcheck_forward_reverse_words(s: String) -> bool { + let a = s.split_word_bounds().collect::>(); + let mut b = s.split_word_bounds().rev().collect::>(); + b.reverse(); + a == b + } + + fn quickcheck_join_words(s: String) -> bool { + let a = s.split_word_bounds().collect::(); + a == s + } +} -- cgit v1.2.1