Verify that the crate works with unic-langid and unic-locale

Author: zbraniecki

Cargo.toml

@@ -19,9 +19,10 @@ coveralls = { repository = "projectfluent/fluent-locale-rs", branch = "master",
 maintenance = { status = "actively-developed" }
 
 [dependencies]
-unic-langid = { path = "../../unic-locale/unic-langid" }
+unic-langid = "^0.3.0"
 
 [dev-dependencies]
 serde = "^1.0"
 serde_json = "^1.0"
 serde_derive = "^1.0"
+unic-locale = "^0.3.0"

src/negotiate/mod.rs

@@ -12,7 +12,7 @@
 //!
 //! ```
 //! use std::convert::TryFrom;
-//! 
+//!
 //! use fluent_locale::negotiate_languages;
 //! use fluent_locale::NegotiationStrategy;
 //! use fluent_locale::convert_vec_str_to_langids;
@@ -339,8 +339,5 @@ pub fn negotiate_languages<
 }
 
 pub fn convert_vec_str_to_langids(input: &[&str]) -> Vec<LanguageIdentifier> {
-    input
-        .iter()
-        .filter_map(|t| (*t).try_into().ok())
-        .collect()
+    input.iter().filter_map(|t| (*t).try_into().ok()).collect()
 }

tests/lib.rs

@@ -1,4 +1,4 @@
-use std::convert::TryInto;
+use std::convert::{TryFrom, TryInto};
 use std::error::Error;
 use std::fs;
 use std::fs::File;
@@ -8,6 +8,7 @@ use fluent_locale::negotiate::negotiate_languages;
 use fluent_locale::negotiate::NegotiationStrategy;
 use fluent_locale::parse_accepted_languages;
 use unic_langid::LanguageIdentifier;
+use unic_locale::Locale;
 
 #[macro_use]
 extern crate serde_derive;
@@ -69,19 +70,19 @@ fn test_negotiate_fixtures(path: &str) {
             }
             NegotiateTestInput::Default(requested, available, default) => {
                 let requested: Vec<LanguageIdentifier> =
-                    dbg!(requested.iter().map(|v| v.try_into().unwrap()).collect());
+                    requested.iter().map(|v| v.try_into().unwrap()).collect();
                 let available: Vec<LanguageIdentifier> =
-                    dbg!(available.iter().map(|v| v.try_into().unwrap()).collect());
+                    available.iter().map(|v| v.try_into().unwrap()).collect();
                 let output: Vec<LanguageIdentifier> =
                     test.output.iter().map(|v| v.try_into().unwrap()).collect();
                 let output2: Vec<&LanguageIdentifier> = output.iter().map(|t| t.as_ref()).collect();
                 assert_eq!(
-                    dbg!(negotiate_languages(
+                    negotiate_languages(
                         &requested,
                         &available,
                         default.try_into().ok().as_ref(),
                         strategy
-                    )),
+                    ),
                     output2,
                     "Test in {} failed",
                     path
@@ -135,3 +136,22 @@ fn accepted_languages() {
         assert_eq!(output, locales);
     }
 }
+
+#[test]
+fn locale_matching() {
+    let loc_en_us = Locale::try_from("en-US-u-hc-h12").expect("Parsing failed.");
+    let loc_de_at = Locale::try_from("de-AT-u-hc-h24").expect("Parsing failed.");
+    let loc_en = Locale::try_from("en-u-ca-buddhist").expect("Parsing failed.");
+    let loc_de = Locale::try_from("de").expect("Parsing failed.");
+    let loc_pl = Locale::try_from("pl-x-private").expect("Parsing failed.");
+
+    assert_eq!(
+        negotiate_languages(
+            vec![&loc_en_us, &loc_de_at],
+            vec![&loc_pl, &loc_de, &loc_en],
+            None,
+            NegotiationStrategy::Matching
+        ),
+        vec![&loc_en, &loc_de],
+    );
+}