public void TurkishI_Is_Differently_LowerUpperCased_In_Turkish_Culture()
{
RemoteExecutorForUap.Invoke(() =>
{
var turkish = new CultureInfo("tr-TR");
string input = "I\u0131\u0130i";
Regex[] cultInvariantRegex = Create(input, CultureInfo.InvariantCulture, RegexOptions.IgnoreCase | RegexOptions.CultureInvariant);
Regex[] turkishRegex = Create(input, turkish, RegexOptions.IgnoreCase);
// same input and regex does match so far so good
Assert.All(cultInvariantRegex, rex => Assert.True(rex.IsMatch(input)));
// when the Regex was created with a turkish locale the lower cased turkish version will
// no longer match the input string which contains upper and lower case iiiis hence even the input string
// will no longer match
Assert.All(turkishRegex, rex => Assert.False(rex.IsMatch(input)));
// Now comes the tricky part depending on the use locale in ToUpper the results differ
// Hence the regular expression will not match if different locales were used
Assert.All(cultInvariantRegex, rex => Assert.True(rex.IsMatch(input.ToLowerInvariant())));
Assert.All(cultInvariantRegex, rex => Assert.False(rex.IsMatch(input.ToLower(turkish))));
Assert.All(turkishRegex, rex => Assert.False(rex.IsMatch(input.ToLowerInvariant())));
Assert.All(turkishRegex, rex => Assert.True(rex.IsMatch(input.ToLower(turkish))));
}).Dispose();
}
public static void CommaDecimalExtremaAndInvalidValuesInvariantBoth(Type type, string min, string max, string value)
{
RemoteExecutorForUap.Invoke((t, m1, m2, v) =>
{
using (new ThreadCultureChange("en-US"))
{
var range = new RangeAttribute(Type.GetType(t), m1, m2)
{
ConvertValueInInvariantCulture = true,
ParseLimitsInInvariantCulture = true
};
AssertExtensions.Throws <ArgumentException>("value", () => range.IsValid(v));
}
using (new ThreadCultureChange("fr-FR"))
{
var range = new RangeAttribute(Type.GetType(t), m1, m2)
{
ConvertValueInInvariantCulture = true,
ParseLimitsInInvariantCulture = true
};
AssertExtensions.Throws <ArgumentException>("value", () => range.IsValid(v));
}
}, type.ToString(), min, max, value).Dispose();
}
public void LocaleOnRootWithoutIsDataSet()
{
RemoteExecutorForUap.Invoke(() =>
{
using (new ThreadCultureChange("fi-FI"))
{
string xs = @"<xs:schema xmlns:xs='http://www.w3.org/2001/XMLSchema' xmlns:msdata='urn:schemas-microsoft-com:xml-msdata'>
<xs:element name='Root' msdata:Locale='ja-JP'>
<xs:complexType>
<xs:sequence>
<xs:element name='Child' type='xs:string' />
</xs:sequence>
<xs:attribute name='Attr' type='xs:integer' />
</xs:complexType>
</xs:element>
</xs:schema>";
var ds = new DataSet();
ds.ReadXmlSchema(new StringReader(xs));
DataSetAssertion.AssertDataSet("ds", ds, "NewDataSet", 1, 0);
Assert.Equal("fi-FI", ds.Locale.Name); // DataSet's Locale comes from current thread
DataTable dt = ds.Tables[0];
DataSetAssertion.AssertDataTable("dt", dt, "Root", 2, 0, 0, 0, 0, 0);
Assert.Equal("ja-JP", dt.Locale.Name); // DataTable's Locale comes from msdata:Locale
DataSetAssertion.AssertDataColumn("col1", dt.Columns[0], "Attr", true, false, 0, 1, "Attr", MappingType.Attribute, typeof(long), DBNull.Value, string.Empty, -1, string.Empty, 0, string.Empty, false, false);
DataSetAssertion.AssertDataColumn("col2", dt.Columns[1], "Child", false, false, 0, 1, "Child", MappingType.Element, typeof(string), DBNull.Value, string.Empty, -1, string.Empty, 1, string.Empty, false, false);
}
}).Dispose();
}
public static void ConvertFrom_InstanceDescriptor()
{
RemoteExecutorForUap.Invoke(() =>
{
using (new ThreadCultureChange("fr-FR"))
{
DateTime testDateAndTime = DateTime.UtcNow;
ConstructorInfo ctor = typeof(DateTime).GetConstructor(new Type[]
{
typeof(int), typeof(int), typeof(int), typeof(int),
typeof(int), typeof(int), typeof(int)
});
InstanceDescriptor descriptor = new InstanceDescriptor(ctor, new object[]
{
testDateAndTime.Year, testDateAndTime.Month, testDateAndTime.Day, testDateAndTime.Hour,
testDateAndTime.Minute, testDateAndTime.Second, testDateAndTime.Millisecond
});
const string format = "dd MMM yyyy hh:mm";
object o = s_converter.ConvertFrom(descriptor);
Assert.Equal(testDateAndTime.ToString(format), ((DateTime)o).ToString(format));
}
}).Dispose();
}
public void Properties()
{
RemoteExecutorForUap.Invoke(() =>
{
using (new ThreadCultureChange("en-AU"))
{
var one = new SqlString("First TestString");
// CompareInfo
Assert.Equal(3081, one.CompareInfo.LCID);
// CultureInfo
Assert.Equal(3081, one.CultureInfo.LCID);
// LCID
Assert.Equal(3081, one.LCID);
// IsNull
Assert.True(!one.IsNull);
Assert.True(SqlString.Null.IsNull);
// SqlCompareOptions
Assert.Equal("IgnoreCase, IgnoreKanaType, IgnoreWidth", one.SqlCompareOptions.ToString());
// Value
Assert.Equal("First TestString", one.Value);
}
}).Dispose();
}
public static void DotDecimalExtremaAndInvalidValuesInvariantBoth(Type type, string min, string max, string value)
{
RemoteExecutorForUap.Invoke((t, m1, m2, v) =>
{
using (new ThreadCultureChange("en-US"))
{
Assert.False(
new RangeAttribute(Type.GetType(t), m1, m2)
{
ConvertValueInInvariantCulture = true,
ParseLimitsInInvariantCulture = true
}.IsValid(v));
}
using (new ThreadCultureChange("fr-FR"))
{
Assert.False(
new RangeAttribute(Type.GetType(t), m1, m2)
{
ConvertValueInInvariantCulture = true,
ParseLimitsInInvariantCulture = true
}.IsValid(v));
}
}, type.ToString(), min, max, value).Dispose();
}
public static void ConvertTo_WithContext()
{
RemoteExecutorForUap.Invoke(() =>
{
using (new ThreadCultureChange("pl-PL"))
{
Assert.Throws <ArgumentNullException>(
() => s_converter.ConvertTo(s_context, null, c_conversionInputValue, null));
Assert.Throws <NotSupportedException>(
() => s_converter.ConvertTo(s_context, null, c_conversionInputValue, typeof(int)));
object o = s_converter.ConvertTo(s_context, null, c_conversionInputValue, typeof(string));
VerifyConversionToString(o);
o = s_converter.ConvertTo(
s_context, CultureInfo.CurrentCulture, c_conversionInputValue, typeof(string));
VerifyConversionToString(o);
o = s_converter.ConvertTo(
s_context, CultureInfo.InvariantCulture, c_conversionInputValue, typeof(string));
VerifyConversionToString(o);
string s = s_converter.ConvertTo(
s_context, CultureInfo.InvariantCulture, new FormattableClass(), typeof(string)) as string;
Assert.NotNull(s);
Assert.Equal(FormattableClass.Token, s);
}
}).Dispose();
}
public void CurrentInfo_Subclass_OverridesNumberFormat()
{
RemoteExecutorForUap.Invoke(() =>
{
using (new ThreadCultureChange(new CultureInfoSubclassOverridesNumberFormat("en-US")))
{
Assert.Same(CultureInfoSubclassOverridesNumberFormat.CustomFormat, NumberFormatInfo.CurrentInfo);
}
}).Dispose();
}
[OuterLoop("May fail on machines with multiple language packs installed")] // https://github.com/dotnet/corefx/issues/39177
public void DisplayName(string name, string expected)
{
RemoteExecutorForUap.Invoke((string _name, string _expected) =>
{
using (new ThreadCultureChange(_name))
{
Assert.Equal(_expected, new RegionInfo(_name).DisplayName);
}
}, name, expected).Dispose();
}
public void DesignerOptionConverter_ConvertToString_ReturnsExpected()
{
RemoteExecutorForUap.Invoke(() =>
{
using (new ThreadCultureChange(null, CultureInfo.InvariantCulture))
{
TypeConverter converter = TypeDescriptor.GetConverter(typeof(DesignerOptionService.DesignerOptionCollection));
Assert.Equal("(Collection)", converter.ConvertToString(null));
}
}).Dispose();
}
public void CurrentInfo_CustomCulture(CultureInfo newCurrentCulture)
{
RemoteExecutorForUap.Invoke((cultureName) =>
{
var newCulture = CultureInfo.GetCultureInfo(cultureName);
using (new ThreadCultureChange(newCulture))
{
Assert.Same(newCulture.NumberFormat, NumberFormatInfo.CurrentInfo);
}
}, newCurrentCulture.Name).Dispose();
}
public void Match_SpecialUnicodeCharacters_enUS()
{
RemoteExecutorForUap.Invoke(() =>
{
using (new ThreadCultureChange("en-US"))
{
Match("\u0131", "\u0049", RegexOptions.IgnoreCase, 0, 1, false, string.Empty);
Match("\u0131", "\u0069", RegexOptions.IgnoreCase, 0, 1, false, string.Empty);
}
}).Dispose();
}
public void XsdSchemaSerializationIgnoresLocale()
{
RemoteExecutorForUap.Invoke(() =>
{
var serializer = new BinaryFormatter();
var table = new DataTable();
table.Columns.Add(new DataColumn("RowID", typeof(int))
{
AutoIncrement = true,
AutoIncrementSeed = -1, // These lines produce attributes within the schema portion of the underlying XML representation of the DataTable with the values "-1" and "-2".
AutoIncrementStep = -2,
});
table.Columns.Add("Value", typeof(string));
table.Rows.Add(1, "Test");
table.Rows.Add(2, "Data");
var buffer = new MemoryStream();
using (new ThreadCultureChange(new CultureInfo("en-US")
{
NumberFormat = new NumberFormatInfo()
{
NegativeSign = "()"
}
}))
{
// Before serializing, update the culture to use a weird negative number format. This test is ensuring that this is ignored.
serializer.Serialize(buffer, table);
}
// The raw serialized data now contains an embedded XML schema. We need to verify that this embedded schema used "-1" for the numeric value
// negative 1, instead of "()1" as indicated by the current culture.
string rawSerializedData = System.Text.Encoding.ASCII.GetString(buffer.ToArray());
const string SchemaStartTag = "<xs:schema";
const string SchemaEndTag = "</xs:schema>";
int schemaStart = rawSerializedData.IndexOf(SchemaStartTag);
int schemaEnd = rawSerializedData.IndexOf(SchemaEndTag);
Assert.True(schemaStart >= 0);
Assert.True(schemaEnd > schemaStart);
Assert.True(rawSerializedData.IndexOf("<xs:schema", schemaStart + 1) < 0);
schemaEnd += SchemaEndTag.Length;
string rawSchemaXML = rawSerializedData.Substring(
startIndex: schemaStart,
length: schemaEnd - schemaStart);
Assert.Contains(@"AutoIncrementSeed=""-1""", rawSchemaXML);
Assert.Contains(@"AutoIncrementStep=""-2""", rawSchemaXML);
Assert.DoesNotContain("()1", rawSchemaXML);
Assert.DoesNotContain("()2", rawSchemaXML);
}).Dispose();
}
public void Chr_CharCodeOutOfRange_ThrowsNotSupportedException(int charCode)
{
RemoteExecutorForUap.Invoke(charCodeInner =>
{
Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
using (new ThreadCultureChange("en-US")) // Strings.Chr doesn't fail on these inputs for all code pages, e.g. 949
{
AssertExtensions.Throws <ArgumentException>(null, () => Strings.Chr(int.Parse(charCodeInner, CultureInfo.InvariantCulture)));
}
}, charCode.ToString(CultureInfo.InvariantCulture)).Dispose();
}
public void NameReturnsUnknownForHandle()
{
RemoteExecutorForUap.Invoke(() =>
{
using (new ThreadCultureChange(CultureInfo.InvariantCulture))
using (FileStream fs = new FileStream(GetTestFilePath(), FileMode.Create, FileAccess.ReadWrite))
using (FileStream fsh = new FileStream(fs.SafeFileHandle, FileAccess.ReadWrite))
{
Assert.Equal("[Unknown]", fsh.Name);
}
}).Dispose();
}
public void CurrentRegion()
{
RemoteExecutorForUap.Invoke(() =>
{
using (new ThreadCultureChange("en-US"))
{
RegionInfo ri = new RegionInfo(new RegionInfo(CultureInfo.CurrentCulture.Name).TwoLetterISORegionName);
Assert.True(RegionInfo.CurrentRegion.Equals(ri) || RegionInfo.CurrentRegion.Equals(new RegionInfo(CultureInfo.CurrentCulture.Name)));
Assert.Same(RegionInfo.CurrentRegion, RegionInfo.CurrentRegion);
}
}).Dispose();
}
public void ConvertFrom_DestinationType_Success()
{
Assert.All(ConvertFromTestData(), convertTest =>
{
// We need to duplicate this test code as RemoteInvoke can't
// create "this" as the declaring type is an abstract class.
if (convertTest.RemoteInvokeCulture == null)
{
if (convertTest.Source != null)
{
Assert.Equal(convertTest.CanConvert, Converter.CanConvertFrom(convertTest.Context, convertTest.Source.GetType()));
}
if (convertTest.NetCoreExceptionType == null)
{
object actual = Converter.ConvertFrom(convertTest.Context, convertTest.Culture, convertTest.Source);
Assert.Equal(convertTest.Expected, actual);
}
else
{
AssertExtensions.Throws(convertTest.NetCoreExceptionType, convertTest.NetFrameworkExceptionType, () => Converter.ConvertFrom(convertTest.Context, convertTest.Culture, convertTest.Source));
}
}
else
{
RemoteExecutorForUap.Invoke((typeName, testString) =>
{
// Deserialize the current test.
TypeConverterTestBase testBase = (TypeConverterTestBase)Activator.CreateInstance(Type.GetType(typeName));
ConvertTest test = ConvertTest.FromSerializedString(testString);
using (new ThreadCultureChange(test.RemoteInvokeCulture))
{
if (test.Source != null)
{
Assert.Equal(test.CanConvert, testBase.Converter.CanConvertFrom(test.Context, test.Source.GetType()));
}
if (test.NetCoreExceptionType == null)
{
object actual = testBase.Converter.ConvertFrom(test.Context, test.Culture, test.Source);
Assert.Equal(test.Expected, actual);
}
else
{
AssertExtensions.Throws(test.NetCoreExceptionType, test.NetFrameworkExceptionType, () => testBase.Converter.ConvertFrom(test.Context, test.Culture, test.Source));
}
}
}, this.GetType().AssemblyQualifiedName, convertTest.GetSerializedString()).Dispose();
}
});
}
public void JsonValue_Parse_Double(string json, double expected)
{
RemoteExecutorForUap.Invoke((jsonInner, expectedInner) =>
{
foreach (string culture in new[] { "en", "fr", "de" })
{
using (new ThreadCultureChange(culture))
{
Assert.Equal(double.Parse(expectedInner, CultureInfo.InvariantCulture), (double)JsonValue.Parse(jsonInner));
}
}
}, json, expected.ToString("R", CultureInfo.InvariantCulture)).Dispose();
}
public static void Test_ToString_NotNetFramework()
{
RemoteExecutorForUap.Invoke(() =>
{
using (new ThreadCultureChange(CultureInfo.InvariantCulture))
{
foreach (object[] testdata in ToString_TestData_NotNetFramework())
{
ToString((double)testdata[0], (string)testdata[1], (IFormatProvider)testdata[2], (string)testdata[3]);
}
}
}).Dispose();
}
public void TestSettingThreadCultures()
{
RemoteExecutorForUap.Invoke(() =>
{
var culture = new CultureInfo("ja-JP");
using (new ThreadCultureChange(culture))
{
var dt = new DateTime(2014, 3, 14, 3, 14, 0);
Assert.Equal(dt.ToString(), dt.ToString(culture));
Assert.Equal(dt.ToString(), dt.ToString(culture.DateTimeFormat));
}
}).Dispose();
}
public static void Invariant_DutchCulture_FormatsDoubleBasedOnInvariantCulture()
{
RemoteExecutorForUap.Invoke(() =>
{
using (new ThreadCultureChange("nl"))
{
double d = 123.456; // would be 123,456 in Dutch
string expected = string.Format(CultureInfo.InvariantCulture, "Invariant culture is used {0}", d);
string actual = FormattableString.Invariant($"Invariant culture is used {d}");
Assert.Equal(expected, actual);
}
}).Dispose();
}
public static void IFormattableToString_UsesSuppliedFormatProvider()
{
RemoteExecutorForUap.Invoke(() =>
{
using (new ThreadCultureChange("nl"))
{
double d = 123.456; // would be 123,456 in Dutch
string expected = string.Format(CultureInfo.InvariantCulture, "Invariant culture is used {0}", d);
string actual = ((IFormattable)((FormattableString)$"Invariant culture is used {d}")).ToString(null, CultureInfo.InvariantCulture);
Assert.Equal(expected, actual);
}
}).Dispose();
}
public static void RunParseToStringTests(CultureInfo culture)
{
RemoteExecutorForUap.Invoke((cultureName) =>
{
byte[] tempByteArray1 = new byte[0];
using (new ThreadCultureChange(cultureName))
{
//default style
VerifyDefaultParse(s_random);
//single NumberStyles
VerifyNumberStyles(NumberStyles.None, s_random);
VerifyNumberStyles(NumberStyles.AllowLeadingWhite, s_random);
VerifyNumberStyles(NumberStyles.AllowTrailingWhite, s_random);
VerifyNumberStyles(NumberStyles.AllowLeadingSign, s_random);
VerifyNumberStyles(NumberStyles.AllowTrailingSign, s_random);
VerifyNumberStyles(NumberStyles.AllowParentheses, s_random);
VerifyNumberStyles(NumberStyles.AllowDecimalPoint, s_random);
VerifyNumberStyles(NumberStyles.AllowThousands, s_random);
VerifyNumberStyles(NumberStyles.AllowExponent, s_random);
VerifyNumberStyles(NumberStyles.AllowCurrencySymbol, s_random);
VerifyNumberStyles(NumberStyles.AllowHexSpecifier, s_random);
//composite NumberStyles
VerifyNumberStyles(NumberStyles.Integer, s_random);
VerifyNumberStyles(NumberStyles.HexNumber, s_random);
VerifyNumberStyles(NumberStyles.Number, s_random);
VerifyNumberStyles(NumberStyles.Float, s_random);
VerifyNumberStyles(NumberStyles.Currency, s_random);
VerifyNumberStyles(NumberStyles.Any, s_random);
//invalid number style
// ******InvalidNumberStyles
NumberStyles invalid = (NumberStyles)0x7c00;
AssertExtensions.Throws <ArgumentException>(null, () =>
{
BigInteger.Parse("1", invalid).ToString("d");
});
AssertExtensions.Throws <ArgumentException>(null, () =>
{
BigInteger junk;
BigInteger.TryParse("1", invalid, null, out junk);
Assert.Equal("1", junk.ToString("d"));
});
//FormatProvider tests
RunFormatProviderParseStrings();
}
}, culture.ToString()).Dispose();
}
public static void ConvertTo_WithContext()
{
RemoteExecutorForUap.Invoke(() =>
{
using (new ThreadCultureChange(null, CultureInfo.InvariantCulture))
{
ConvertTo_WithContext(new object[1, 3]
{
{ "any string", "(Text)", null }
},
new MultilineStringConverter());
}
}).Dispose();
}
public static void CurrentCulture_DutchCulture_FormatsDoubleBasedOnCurrentCulture()
{
RemoteExecutorForUap.Invoke(() =>
{
var dutchCulture = new CultureInfo("nl");
using (new ThreadCultureChange(dutchCulture))
{
double d = 123.456;
string expected = string.Format(dutchCulture, "Dutch decimal separator is comma {0}", d);
string actual = FormattableString.CurrentCulture($"Dutch decimal separator is comma {d}");
Assert.Equal(expected, actual);
}
}).Dispose();
}
[InlineData(1.123456789e-28)] // Values around the smallest positive decimal value
public void JsonValue_Parse_Double_ViaJsonPrimitive(double number)
{
RemoteExecutorForUap.Invoke(numberText =>
{
double numberInner = double.Parse(numberText, CultureInfo.InvariantCulture);
foreach (string culture in new[] { "en", "fr", "de" })
{
using (new ThreadCultureChange(culture))
{
Assert.Equal(numberInner, (double)JsonValue.Parse(new JsonPrimitive(numberInner).ToString()));
}
}
}, number.ToString("R", CultureInfo.InvariantCulture)).Dispose();
}
public static void ConvertTo_WithContext()
{
RemoteExecutorForUap.Invoke(() =>
{
using (new ThreadCultureChange(CultureInfo.InvariantCulture))
{
ConvertTo_WithContext(new object[2, 3]
{
{ typeof(char), "System.Char", null }, // the base class is not verifying if this type is not in the list
{ null, "(none)", CultureInfo.InvariantCulture }
},
TypeListConverterTests.s_converter);
}
}).Dispose();
}
public void Asc_Chr_DoubleByte(int charCode, int expected)
{
RemoteExecutorForUap.Invoke((charCodeString, expectedString) =>
{
int charCode = int.Parse(charCodeString);
int expected = int.Parse(expectedString);
Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
using (new ThreadCultureChange("ko-KR"))
{
Assert.Equal(949, CultureInfo.CurrentCulture.TextInfo.ANSICodePage);
Assert.Equal(expected, (ushort)Strings.Asc(Strings.Chr(charCode)));
}
}, charCode.ToString(), expected.ToString()).Dispose();
}
public static void ParseCommaSeparatorInvariantExtremaInCommaSeparatorCultures(Type type, string min, string max)
{
RemoteExecutorForUap.Invoke((t, m1, m2) =>
{
using (new ThreadCultureChange("en-US"))
{
var range = new RangeAttribute(Type.GetType(t), m1, m2);
AssertExtensions.Throws <ArgumentException>("value", () => range.IsValid(null));
}
using (new ThreadCultureChange("fr-FR"))
{
Assert.True(new RangeAttribute(Type.GetType(t), m1, m2).IsValid(null));
}
}, type.ToString(), min, max).Dispose();
}
public static void DotDecimalExtremaAndInvalidValues(Type type, string min, string max, string value)
{
RemoteExecutorForUap.Invoke((t, m1, m2, v) =>
{
using (new ThreadCultureChange("en-US"))
{
Assert.False(new RangeAttribute(Type.GetType(t), m1, m2).IsValid(v));
}
using (new ThreadCultureChange("fr-FR"))
{
var range = new RangeAttribute(Type.GetType(t), m1, m2);
AssertExtensions.Throws <ArgumentException>("value", () => range.IsValid(v));
}
}, type.ToString(), min, max, value).Dispose();
}
