public void With_should_return_expected_result(
[Values("en_US", "fr_CA")]
string locale)
{
var subject = new Collation(locale);
var result = subject.With();
result.Should().Be(subject);
}
public void With_should_return_expected_result_when_maxVariable_is_set(
[Values(null, CollationMaxVariable.Punctuation, CollationMaxVariable.Space)]
CollationMaxVariable?originalMaxVariable,
[Values(null, CollationMaxVariable.Punctuation, CollationMaxVariable.Space)]
CollationMaxVariable?maxVariable)
{
var subject = new Collation("en_US", maxVariable: originalMaxVariable);
var result = subject.With(maxVariable: maxVariable);
result.MaxVariable.Should().Be(maxVariable);
result.With(maxVariable: originalMaxVariable).Should().Be(subject);
}
public void With_should_return_expected_result_when_locale_is_set(
[Values("en_US", "fr_CA")]
string originalLocale,
[Values("en_US", "fr_CA")]
string locale)
{
var subject = new Collation(originalLocale);
var result = subject.With(locale: locale);
result.Locale.Should().Be(locale);
result.With(locale: originalLocale).Should().Be(subject);
}
public void With_should_return_expected_result_when_caseLevel_is_set(
[Values(null, false, true)]
bool?originalCaseLevel,
[Values(null, false, true)]
bool?caseLevel)
{
var subject = new Collation("en_US", caseLevel: originalCaseLevel);
var result = subject.With(caseLevel: caseLevel);
result.CaseLevel.Should().Be(caseLevel);
result.With(caseLevel: originalCaseLevel).Should().Be(subject);
}
public void With_should_return_expected_result_when_caseFirst_is_set(
[Values(null, CollationCaseFirst.Lower, CollationCaseFirst.Upper)]
CollationCaseFirst?originalCaseFirst,
[Values(null, CollationCaseFirst.Lower, CollationCaseFirst.Upper)]
CollationCaseFirst?caseFirst)
{
var subject = new Collation("en_US", caseFirst: originalCaseFirst);
var result = subject.With(caseFirst: caseFirst);
result.CaseFirst.Should().Be(caseFirst);
result.With(caseFirst: originalCaseFirst).Should().Be(subject);
}
public void With_should_return_expected_result_when_backwards_is_set(
[Values(null, false, true)]
bool?originalBackwards,
[Values(null, false, true)]
bool?backwards)
{
var subject = new Collation("en_US", backwards: originalBackwards);
var result = subject.With(backwards: backwards);
result.Backwards.Should().Be(backwards);
result.With(backwards: originalBackwards).Should().Be(subject);
}
public void With_should_return_expected_result_when_alternate_is_set(
[Values(null, CollationAlternate.NonIgnorable, CollationAlternate.Shifted)]
CollationAlternate?originalAlternate,
[Values(null, CollationAlternate.NonIgnorable, CollationAlternate.Shifted)]
CollationAlternate?alternate)
{
var subject = new Collation("en_US", alternate: originalAlternate);
var result = subject.With(alternate: alternate);
result.Alternate.Should().Be(alternate);
result.With(alternate: originalAlternate).Should().Be(subject);
}
public void With_should_return_expected_result_when_strength_is_set(
[Values(null, CollationStrength.Primary, CollationStrength.Identical)]
CollationStrength?originalStrength,
[Values(null, CollationStrength.Primary, CollationStrength.Identical)]
CollationStrength?strength)
{
var subject = new Collation("en_US", strength: originalStrength);
var result = subject.With(strength: strength);
result.Strength.Should().Be(strength);
result.With(strength: originalStrength).Should().Be(subject);
}
public void With_should_return_expected_result_when_numericOrdering_is_set(
[Values(null, false, true)]
bool?originalNumericOrdering,
[Values(null, false, true)]
bool?numericOrdering)
{
var subject = new Collation("en_US", numericOrdering: originalNumericOrdering);
var result = subject.With(numericOrdering: numericOrdering);
result.NumericOrdering.Should().Be(numericOrdering);
result.With(numericOrdering: originalNumericOrdering).Should().Be(subject);
}
public void With_should_return_expected_result_when_normalization_is_set(
[Values(null, false, true)]
bool?originalNormalization,
[Values(null, false, true)]
bool?normalization)
{
var subject = new Collation("en_US", normalization: originalNormalization);
var result = subject.With(normalization: normalization);
result.Normalization.Should().Be(normalization);
result.With(normalization: originalNormalization).Should().Be(subject);
}