map_wtf8(text, |s, out| {

CaseMapper::new()

.fold(s)

.write_to(out)

.expect("writing to an in-memory buffer cannot fail");

})

let mut out = Vec::with_capacity(text.len());

capitalize_utf8(text, &mut FmtWriter(&mut out));

// SAFETY: capitalize_utf8 only appends valid UTF-8.

unsafe { String::from_utf8_unchecked(out) }

let mut out = Vec::with_capacity(text.len());

let mut first = true;

for chunk in text.chunks() {

match chunk {

Wtf8Chunk::Utf8(s) => {

let mut writer = FmtWriter(&mut out);

if first {

capitalize_utf8(s, &mut writer);

first = false;

} else {

for (i, ch) in s.char_indices() {

lowercase_or_sigma(ch, s, i, &mut writer);

}

}

}

Wtf8Chunk::Surrogate(c) => {

first = false;

push_surrogate(&mut out, c);

}

}

}

// SAFETY:

// * capitalize_utf8 / lowercase_or_sigma only append valid UTF-8.

// * Surrogates are appended as valid WTF-8 (encoded via Wtf8Buf::push).

unsafe { Wtf8Buf::from_bytes_unchecked(out) }

let mut out = Vec::with_capacity(text.len());

titlecase_string(text, &mut FmtWriter(&mut out));

// SAFETY: titlecase_string only appends valid UTF-8.

unsafe { String::from_utf8_unchecked(out) }

let mut out = Vec::with_capacity(text.len());

swapcase_utf8(text, &mut FmtWriter(&mut out));

// SAFETY: swapcase_utf8 only appends valid UTF-8.

unsafe { String::from_utf8_unchecked(out) }

let mut out = Vec::with_capacity(text.len());

for chunk in text.chunks() {

match chunk {

Wtf8Chunk::Utf8(s) => f(s, &mut FmtWriter(&mut out)),

Wtf8Chunk::Surrogate(c) => push_surrogate(&mut out, c),

}

}

// SAFETY:

// * `f` only appends valid UTF-8.

// * Surrogates are appended as valid WTF-8 (encoded via Wtf8Buf::push).

unsafe { Wtf8Buf::from_bytes_unchecked(out) }

let mut buf = Wtf8Buf::new();

buf.push(c);

out.extend_from_slice(buf.as_bytes());

let mut chars = s.char_indices();

if let Some((first_pos, first_ch)) = chars.next() {

let first = &s[..first_pos + first_ch.len_utf8()];

titlecase_segment(first, out);

}

for (i, ch) in chars {

lowercase_or_sigma(ch, s, i, out);

}

let mut previous_is_cased = false;

for (i, ch) in s.char_indices() {

if previous_is_cased {

lowercase_or_sigma(ch, s, i, out);

} else {

titlecase_segment(&s[i..i + ch.len_utf8()], out);

}

previous_is_cased = is_cased(ch);

}

// Callers pass a single first-of-word code point, which Python titlecases

// unconditionally (applying its titlecase mapping). The default `Auto`

// leading adjustment looks for a head in Letter/Number/Symbol/Private_Use

// and skips anything else, dropping the titlecase mapping of cased marks

// such as U+0345 (`ͅ`, general category Mn) -> U+0399 (`Ι`). `None`

// titlecases the code point as given.

let mut options = TitlecaseOptions::default();

options.leading_adjustment = Some(LeadingAdjustment::None);

TitlecaseMapper::new()

.titlecase_segment(s, &LanguageIdentifier::UNKNOWN, options)

.write_to(out)

.expect("writing to an in-memory buffer cannot fail");

let sigma = 'Σ';

if ch == sigma {

push_char(handle_capital_sigma(s, i), out);

} else {

for ch in ch.to_lowercase() {

push_char(ch, out);

}

}

let (left, rest) = s.split_at(i);

let right = &rest['Σ'.len_utf8()..];

// Check if any chars before or after sigma are cased.

let before = left

.chars()

.rev()

.find(|&ch| !is_case_ignorable(ch))

.is_some_and(is_cased);

let after = right

.chars()

.find(|&ch| !is_case_ignorable(ch))

.is_some_and(is_cased);

if before && !after { 'ς' } else { 'σ' }

for (i, ch) in s.char_indices() {

if ch.is_uppercase() {

lowercase_or_sigma(ch, s, i, out);

} else if ch.is_lowercase() {

for ch in ch.to_uppercase() {

push_char(ch, out);

}

} else {

push_char(ch, out);

}

}

fn write_str(&mut self, s: &str) -> core::fmt::Result {

self.0.extend_from_slice(s.as_bytes());

Ok(())

}

use rustpython_wtf8::{CodePoint, Wtf8Buf};

use super::{

capitalize_str, casefold_str, is_case_ignorable, is_cased, is_lowercase, is_titlecase,

is_uppercase, simple_lowercase, simple_uppercase, swapcase_str, title_str, title_wtf8,

};

#[test]

fn casefold_full_mappings() {

// ß case-folds to "ss"

assert_eq!(casefold_str("ß"), "ss");

assert_eq!(casefold_str("Σ"), "σ");

}

#[test]

fn simple_mappings_are_one_to_one() {

// ß has no simple uppercase mapping, so it stays unchanged (unlike the

// full mapping "SS").

assert_eq!(simple_uppercase('ß'), 'ß');

assert_eq!(simple_uppercase('a'), 'A');

assert_eq!(simple_lowercase('A'), 'a');

// Dž (U+01C5) simple-titlecases to itself but upper/lowercases away.

assert_eq!(simple_uppercase('Dž'), 'DŽ');

assert_eq!(simple_lowercase('Dž'), 'dž');

}

#[test]

fn casing_predicates() {

assert!(is_lowercase('a'));

assert!(!is_lowercase('A'));

assert!(is_uppercase('A'));

assert!(is_titlecase('Dž'));

assert!(!is_titlecase('D'));

assert!(is_cased('a') && is_cased('A'));

assert!(!is_cased('1'));

assert!(is_case_ignorable('\''));

assert!(!is_case_ignorable('a'));

}

#[test]

fn capitalize_final_sigma() {

// Final sigma at end of a cased run becomes ς.

assert_eq!(capitalize_str("ΟΔΟΣ"), "Οδος");

assert_eq!(title_str("hello world"), "Hello World");

assert_eq!(swapcase_str("Hello"), "hELLO");

}

#[test]

fn titlecase_first_of_word_takes_titlecase_mapping() {

// A leading cased combining mark still takes its titlecase mapping:

// U+0345 (ͅ, general category Mn) titlecases to U+0399 (Ι), even though

// it is not a Letter/Number/Symbol head.

assert_eq!(title_str("\u{0345}"), "\u{0399}");

assert_eq!(capitalize_str("\u{0345}"), "\u{0399}");

assert_eq!(title_str("\u{0345}a"), "\u{0399}a");

// Full (one-to-many) titlecase mappings still apply to the first

// character of each word.

// cspell:ignore finnish NNISH dzungla Dzungla ßhello Sshello

assert_eq!(capitalize_str("finnish"), "Finnish");

assert_eq!(title_str("fiNNISH"), "Finnish");

assert_eq!(capitalize_str("dzungla"), "Dzungla");

assert_eq!(capitalize_str("ßhello"), "Sshello");

}

#[test]

fn wtf8_passes_surrogates_through() {

let mut buf = Wtf8Buf::from("ab cd");

buf.push(CodePoint::from_u32(0xD800).unwrap());

let titled = title_wtf8(&buf);

assert!(titled.code_points().any(|c| c.to_u32() == 0xD800));

assert_eq!(

titled.code_points().next().and_then(|c| c.to_char()),

Some('A')

);

}