License for sse4-strstr (https://github.com/WojciechMula/sse4-strstr)
--------------------------------------
- Copyright (c) 2008-2016, Wojciech Muła
+ Copyright (c) 2008-2016, Wojciech Mula
All rights reserved.
Redistribution and use in source and binary forms, with or without
The Native AOT compiler supports the [documented options](https://docs.microsoft.com/en-us/dotnet/core/deploying/trim-self-contained) for removing unused code (trimming). By default, the compiler tries to very conservatively remove some of the unused code.
-🛈 Native AOT difference: The documented `PublishTrimmed` property is implied to be `true` when Native AOT is active.
+:information_source: Native AOT difference: The documented `PublishTrimmed` property is implied to be `true` when Native AOT is active.
By default, the compiler tries to maximize compatibility with existing .NET code at the expense of compilation speed and size of the output executable. This allows people to use their existing code that worked well in a fully dynamic mode without hitting issues caused by trimming. To read more about reflection, see the [Reflection in AOT mode](reflection-in-aot-mode.md) document.
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("parse-hb-log")]
-[assembly: AssemblyCopyright("Copyright © 2019")]
+[assembly: AssemblyCopyright("Copyright \u00A9 2019")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// pass-zero-pass1-nX-ia1-thread.txt
//
// thread tells you the thread index running on each proc at each timestamp.
-// 4240| 63₉ | 65₉ | 62₉ | 56₁₀| 87₁₀|109₁₀| 59₉ | 70₁₀| 78₉ | 64₉ | 71₁₀|107₁₀|
+// 4240| 63\u2089 | 65\u2089 | 62\u2089 | 56\u2081\u2080| 87\u2081\u2080|109\u2081\u2080| 59\u2089 | 70\u2081\u2080| 78\u2089 | 64\u2089 | 71\u2081\u2080|107\u2081\u2080|
//
// 4240 is the 4240th ms since we started recording.
// the numbers following are the thread indices and the subscript is the # of samples
// observed during that ms. The tool can do a time unit that's larger than 1ms.
//
// alloc tells you which alloc heap the each proc, for the same timestamp
-// 4240| 56 | 57 | 58ⁱ | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 |
+// 4240| 56 | 57 | 58\u2071 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 |
// 56 means heap 56. The subscript i means we did a SetIdealProcessor during this
// ms. You may also see
-// ᵖ meaning we went through the balancing logic due to the proc for the thread changed
+// \u1D56 meaning we went through the balancing logic due to the proc for the thread changed
// from the home heap.
-// ᵐ meaning while we were going through balancing logic the proc switched.
+// \u1D50 meaning while we were going through balancing logic the proc switched.
using System;
using System.Collections.Generic;
string strFormattedFlags = "";
if ((flags & (int)HeapBalanceFlagMask.MutipleProcs) != 0)
{
- strFormattedFlags += "ᵐ";
+ strFormattedFlags += "\u1D50";
}
if ((flags & (int)HeapBalanceFlagMask.EnterDueToProc) != 0)
{
- strFormattedFlags += "ᵖ";
+ strFormattedFlags += "\u1D56";
}
if ((flags & (int)HeapBalanceFlagMask.SetIdeal) != 0)
{
- strFormattedFlags += "ⁱ";
+ strFormattedFlags += "\u2071";
}
return strFormattedFlags;
// see https://en.wikipedia.org/wiki/Unicode_subscripts_and_superscripts
// for subscript characters
- // ᵐ,ᵖ,ⁱ
+ // \u1D50,\u1D56,\u2071
if (fPrint)
{
int procsHadSamples = 0;
// The MIT License(MIT)
// =====================
//
-// Copyright © `2015-2017` `Lucas Meijer`
+// Copyright \u00A9 `2015-2017` `Lucas Meijer`
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
-// files (the “Software”), to deal in the Software without
+// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
-// THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND,
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
int shareWidth = (int)(Math.Round(share * tableWidth));
bool lastRow = (i == rows.Length - 1);
- Console.Write($" {(lastRow ? "≥" : " ")}{i,2}: [");
+ Console.Write($" {(lastRow ? "\u2265" : " ")}{i,2}: [");
Console.Write(new string('#', shareWidth));
Console.Write(new string('.', tableWidth - shareWidth));
Console.Write("] ");
.Should()
.Pass()
.And
- .HaveStdOutContaining("ನಮಸ್ಕಾರ! வணக்கம்! Hello!");
+ .HaveStdOutContaining("\u0CA8\u0CAE\u0CB8\u0CCD\u0C95\u0CBE\u0CB0! \u0BB5\u0BA3\u0B95\u0BCD\u0B95\u0BAE\u0BCD! Hello!");
}
public class SharedTestState : SharedTestStateBase, IDisposable
.CaptureStdOut()
.Execute()
.Should().Pass()
- .And.HaveStdOutContaining("ನಮಸ್ಕಾರ! வணக்கம்! Hello!");
+ .And.HaveStdOutContaining("\u0CA8\u0CAE\u0CB8\u0CCD\u0C95\u0CBE\u0CB0! \u0BB5\u0BA3\u0B95\u0BCD\u0B95\u0BAE\u0BCD! Hello!");
}
public class SharedTestState : IDisposable
// https://github.com/dotnet/runtime/issues/44681
public void DictionaryOrdinalIgnoreCaseCyrillicKeys()
{
- const string Lower = "абвгдеёжзийклмнопрстуфхцчшщьыъэюя";
- const string Higher = "АБВГДЕЁЖЗИЙКЛМНОПРСТУФХЦЧШЩЬЫЪЭЮЯ";
+ const string Lower = "\u0430\u0431\u0432\u0433\u0434\u0435\u0451\u0436\u0437\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u0440\u0441\u0442\u0443\u0444\u0445\u0446\u0447\u0448\u0449\u044C\u044B\u044A\u044D\u044E\u044F";
+ const string Higher = "\u0410\u0411\u0412\u0413\u0414\u0415\u0401\u0416\u0417\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u0420\u0421\u0422\u0423\u0424\u0425\u0426\u0427\u0428\u0429\u042C\u042B\u042A\u042D\u042E\u042F";
var dictionary = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
("Hello", "hello"), // case-insensitive equal\r
("Hello", "He\u200dllo"), // equal under linguistic comparer\r
("Hello", "HE\u200dLLO"), // equal under case-insensitive linguistic comparer\r
- ("абвгдеёжзийклмнопрстуфхцчшщьыъэюя", "АБВГДЕЁЖЗИЙКЛМНОПРСТУФХЦЧШЩЬЫЪЭЮЯ"), // Cyrillic, case-insensitive equal\r
+ ("\u0430\u0431\u0432\u0433\u0434\u0435\u0451\u0436\u0437\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u0440\u0441\u0442\u0443\u0444\u0445\u0446\u0447\u0448\u0449\u044C\u044B\u044A\u044D\u044E\u044F", "\u0410\u0411\u0412\u0413\u0414\u0415\u0401\u0416\u0417\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u0420\u0421\u0422\u0423\u0424\u0425\u0426\u0427\u0428\u0429\u042C\u042B\u042A\u042D\u042E\u042F"), // Cyrillic, case-insensitive equal\r
})\r
{\r
bool arePairElementsExpectedEqual = publicComparer.Equals(pair.Item1, pair.Item2);\r
-// Licensed to the .NET Foundation under one or more agreements.
+// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Configuration;
// The .NET Foundation licenses this file to you under the MIT license.
//
// Authors:
-// Jordi Mas i Hernàndez (jordi@ximian.com)
+// Jordi Mas i Hernandez (jordi@ximian.com)
// Sebastien Pouliot <sebastien@ximian.com>
//
// (C) 2004 Ximian, Inc. http://www.ximian.com
//
// Author:
//
-// Jordi Mas i Hernandez, jordimash@gmail.com
+// Jordi Mas i Hernandez (jordi@ximian.com)
//
using Xunit;
//
// Author:
//
-// Jordi Mas i Hernandez, jordimash@gmail.com
+// Jordi Mas i Hernandez (jordi@ximian.com)
//
using Xunit;
// BMPCodec class testing unit
//
// Authors:
-// Jordi Mas i Hern?ndez (jordi@ximian.com)
+// Jordi Mas i Hernandez (jordi@ximian.com)
// Sebastien Pouliot <sebastien@ximian.com>
//
// (C) 2004 Ximian, Inc. http://www.ximian.com
// GIF Codec class testing unit
//
// Authors:
-// Jordi Mas i Hern?ndez (jordi@ximian.com)
+// Jordi Mas i Hernandez (jordi@ximian.com)
// Sebastien Pouliot <sebastien@ximian.com>
//
// Copyright (C) 2006, 2007 Novell, Inc (http://www.novell.com)
// ICO Codec class testing unit
//
// Authors:
-// Jordi Mas i Hern?ndez (jordi@ximian.com)
+// Jordi Mas i Hernandez (jordi@ximian.com)
// Sebastien Pouliot <sebastien@ximian.com>
//
// Copyright (C) 2006-2007 Novell, Inc (http://www.novell.com)
// JpegCodec class testing unit
//
// Authors:
-// Jordi Mas i Hern?ndez (jordi@ximian.com)
+// Jordi Mas i Hernandez (jordi@ximian.com)
// Sebastien Pouliot <sebastien@ximian.com>
//
// (C) 2004 Ximian, Inc. http://www.ximian.com
// PNG Codec class testing unit
//
// Authors:
-// Jordi Mas i Hern?ndez (jordi@ximian.com)
+// Jordi Mas i Hernandez (jordi@ximian.com)
// Sebastien Pouliot <sebastien@ximian.com>
//
// Copyright (C) 2006, 2007 Novell, Inc (http://www.novell.com)
// TIFF Codec class testing unit
//
// Authors:
-// Jordi Mas i Hern?ndez (jordi@ximian.com)
+// Jordi Mas i Hernandez (jordi@ximian.com)
// Sebastien Pouliot <sebastien@ximian.com>
//
// Copyright (C) 2006, 2007 Novell, Inc (http://www.novell.com)
// Bitmap class testing unit
//
// Authors:
-// Jordi Mas i Hern?ndez (jmas@softcatala.org>
+// Jordi Mas i Hernandez (jordi@ximian.com)
// Jonathan Gilbert <logic@deltaq.org>
// Sebastien Pouliot <sebastien@ximian.com>
//
TarEntry directory = await reader.GetNextEntryAsync();
- VerifyDirectoryEntry(directory, format, "f\u00f6ld\u00ebr/"); //földër
+ VerifyDirectoryEntry(directory, format, "f\u00f6ld\u00ebr/");
TarEntry file = await reader.GetNextEntryAsync();
- VerifyRegularFileEntry(file, format, "f\u00f6ld\u00ebr/\u00e1\u00f6\u00f1.txt", $"Hello {testCaseName}"); // földër/áöñ.txt
+ VerifyRegularFileEntry(file, format, "f\u00f6ld\u00ebr/\u00e1\u00f6\u00f1.txt", $"Hello {testCaseName}");
Assert.Null(await reader.GetNextEntryAsync());
}
TarEntry directory = reader.GetNextEntry();
- VerifyDirectoryEntry(directory, format, "f\u00f6ld\u00ebr/"); //földër
+ VerifyDirectoryEntry(directory, format, "f\u00f6ld\u00ebr/");
TarEntry file = reader.GetNextEntry();
- VerifyRegularFileEntry(file, format, "f\u00f6ld\u00ebr/\u00e1\u00f6\u00f1.txt", $"Hello {testCaseName}"); // földër/áöñ.txt
+ VerifyRegularFileEntry(file, format, "f\u00f6ld\u00ebr/\u00e1\u00f6\u00f1.txt", $"Hello {testCaseName}");
Assert.Null(reader.GetNextEntry());
}
[Fact]
public void TestIgnoreKanaAndWidthCases()
{
- for (char c = '\uFF41'; c <= '\uFF5A'; c++) // Full width 'ａ' to `ｚ`
+ for (char c = '\uFF41'; c <= '\uFF5A'; c++)
{
Assert.False(string.Equals(new string(c, 1), new string((char) (c - 0x20), 1), StringComparison.InvariantCulture), $"Expected '{(int)c:x4}' != '{c - 0x20:x4}'");
Assert.True(string.Equals(new string(c, 1), new string((char) (c - 0x20), 1), StringComparison.InvariantCultureIgnoreCase), $"Expected '{(int)c:x4}' == '{c - 0x20:x4}'");
yield return new object[] { s_invariantCompare, "hello", "\u200d", 4, 5, CompareOptions.IgnoreCase, 5, 0};
yield return new object[] { s_invariantCompare, "hello", "\0", 4, 5, CompareOptions.None, useNls ? -1 : 5, 0};
- yield return new object[] { s_invariantCompare, "A\u0303", "\u200d", 1, 2, CompareOptions.None, 2, 0}; // A + ̃ = Ã
- yield return new object[] { s_invariantCompare, "A\u0303\u200D", "\u200d", 2, 3, CompareOptions.None, 3, 0}; // A + ̃ = Ã
+ yield return new object[] { s_invariantCompare, "A\u0303", "\u200d", 1, 2, CompareOptions.None, 2, 0};
+ yield return new object[] { s_invariantCompare, "A\u0303\u200D", "\u200d", 2, 3, CompareOptions.None, 3, 0};
yield return new object[] { s_invariantCompare, "\u0001F601", "\u200d", 1, 2, CompareOptions.None, 2, 0}; // \u0001F601 is GRINNING FACE WITH SMILING EYES surrogate character
yield return new object[] { s_invariantCompare, "AA\u200DA", "\u200d", 3, 4, CompareOptions.None, 4, 0};
[InlineData("en", "fr", "English", "anglais")]
[InlineData("aa", "aa", "Afar", "Afar")]
[InlineData("en-US", "en-US", "English (United States)", "English (United States)")]
- [InlineData("en-US", "fr-FR", "English (United States)", "anglais (États-Unis)")]
+ [InlineData("en-US", "fr-FR", "English (United States)", "anglais (\u00C9tats-Unis)")]
[InlineData("en-US", "de-DE", "English (United States)", "Englisch (Vereinigte Staaten)")]
[InlineData("aa-ER", "aa-ER", "Afar (Eritrea)", "Afar (Eritrea)")]
[InlineData("", "en-US", "Invariant Language (Invariant Country)", "Invariant Language (Invariant Country)")]
CultureInfo ci = new CultureInfo("en-US");
Assert.Equal("English (United States)", ci.DisplayName);
CultureInfo.CurrentUICulture = CultureInfo.GetCultureInfo("fr-FR");
- Assert.Equal("anglais (États-Unis)", ci.DisplayName);
+ Assert.Equal("anglais (\u00C9tats-Unis)", ci.DisplayName);
CultureInfo.CurrentUICulture = CultureInfo.GetCultureInfo("de-DE");
Assert.Equal("Englisch (Vereinigte Staaten)", ci.DisplayName);
}
continue;
}
- // Line has format "÷ (XXXX (× YYYY)* ÷)+ # <comment>"
+ // Line has format "\u00F7 (XXXX (\u00D7 YYYY)* \u00F7)+ # <comment>"
// We'll yield return a Rune[][], representing a collection of clusters, where each cluster contains a collection of Runes.
//
- // Example: "÷ AAAA ÷ BBBB × CCCC × DDDD ÷ EEEE × FFFF ÷ # <comment>"
+ // Example: "\u00F7 AAAA \u00F7 BBBB \u00D7 CCCC \u00D7 DDDD \u00F7 EEEE \u00D7 FFFF \u00F7 # <comment>"
// -> [ [ AAAA ], [ BBBB, CCCC, DDDD ], [ EEEE, FFFF ] ]
//
// We also return the line for ease of debugging any test failures.
[Fact]
public void CultureOrderBy()
{
- string[] source = new[] { "Apple0", "Æble0", "Apple1", "Æble1", "Apple2", "Æble2" };
+ string[] source = new[] { "Apple0", "\uFFFDble0", "Apple1", "\uFFFDble1", "Apple2", "\uFFFDble2" };
CultureInfo dk = new CultureInfo("da-DK");
CultureInfo au = new CultureInfo("en-AU");
[Fact]
public void CultureOrderByElementAt()
{
- string[] source = new[] { "Apple0", "Æble0", "Apple1", "Æble1", "Apple2", "Æble2" };
+ string[] source = new[] { "Apple0", "\uFFFDble0", "Apple1", "\uFFFDble1", "Apple2", "\uFFFDble2" };
CultureInfo dk = new CultureInfo("da-DK");
CultureInfo au = new CultureInfo("en-AU");
[Fact]
public void CultureOrder()
{
- string[] source = new[] { "Apple0", "Æble0", "Apple1", "Æble1", "Apple2", "Æble2" };
+ string[] source = new[] { "Apple0", "\u00C6ble0", "Apple1", "\u00C6ble1", "Apple2", "\u00C6ble2" };
CultureInfo dk = new CultureInfo("da-DK");
CultureInfo au = new CultureInfo("en-AU");
[Fact]
public void CultureOrderElementAt()
{
- string[] source = new[] { "Apple0", "Æble0", "Apple1", "Æble1", "Apple2", "Æble2" };
+ string[] source = new[] { "Apple0", "\u00C6ble0", "Apple1", "\u00C6ble1", "Apple2", "\u00C6ble2" };
CultureInfo dk = new CultureInfo("da-DK");
CultureInfo au = new CultureInfo("en-AU");
yield return new object[] { "1111x1211111111111x12111122131221221211221111112121121", "1111111211111111", -1, -1 };
yield return new object[] { "1111x1211111111111x12111122131221221211221111112121121", "111211111111111111", -1, -1 };
yield return new object[] { "1111x1211111111111x12111122131221221211221111112121121", "11111211111121111111", -1, -1 };
- yield return new object[] { "жжжжжжжжжжжжжж", "жжж", 0, 11 };
- yield return new object[] { "жжжжжжжжжжжжжжжжжжжжжжжжжжжж", "ж0ж", -1, -1 };
- yield return new object[] { "жжжжжаааааааааааааааччччс", "ччччс", 20, 20 };
- yield return new object[] { "жжжжжаааааааааааааааччччсссссссчччч", "чччч", 20, 31 };
- yield return new object[] { "жжжжжжжжжжжжжжжжжжжжжжжжжжжж", "1112", -1, -1 };
- yield return new object[] { "0уза0оцущ0оаз0щцуоазщцуо0азщцуоазщоц0узозцуоазуоцз0щауцз0оазцо", "0оаз0", 9, 9 };
+ yield return new object[] { "\u0436\u0436\u0436\u0436\u0436\u0436\u0436\u0436\u0436\u0436\u0436\u0436\u0436\u0436", "\u0436\u0436\u0436", 0, 11 };
+ yield return new object[] { "\u0436\u0436\u0436\u0436\u0436\u0436\u0436\u0436\u0436\u0436\u0436\u0436\u0436\u0436\u0436\u0436\u0436\u0436\u0436\u0436\u0436\u0436\u0436\u0436\u0436\u0436\u0436\u0436", "\u04360\u0436", -1, -1 };
+ yield return new object[] { "\u0436\u0436\u0436\u0436\u0436\u0430\u0430\u0430\u0430\u0430\u0430\u0430\u0430\u0430\u0430\u0430\u0430\u0430\u0430\u0430\u0447\u0447\u0447\u0447\u0441", "\u0447\u0447\u0447\u0447\u0441", 20, 20 };
+ yield return new object[] { "\u0436\u0436\u0436\u0436\u0436\u0430\u0430\u0430\u0430\u0430\u0430\u0430\u0430\u0430\u0430\u0430\u0430\u0430\u0430\u0430\u0447\u0447\u0447\u0447\u0441\u0441\u0441\u0441\u0441\u0441\u0441\u0447\u0447\u0447\u0447", "\u0447\u0447\u0447\u0447", 20, 31 };
+ yield return new object[] { "\u0436\u0436\u0436\u0436\u0436\u0436\u0436\u0436\u0436\u0436\u0436\u0436\u0436\u0436\u0436\u0436\u0436\u0436\u0436\u0436\u0436\u0436\u0436\u0436\u0436\u0436\u0436\u0436", "1112", -1, -1 };
+ yield return new object[] { "0\u0443\u0437\u04300\u043E\u0446\u0443\u04490\u043E\u0430\u04370\u0449\u0446\u0443\u043E\u0430\u0437\u0449\u0446\u0443\u043E0\u0430\u0437\u0449\u0446\u0443\u043E\u0430\u0437\u0449\u043E\u04460\u0443\u0437\u043E\u0437\u0446\u0443\u043E\u0430\u0437\u0443\u043E\u0446\u04370\u0449\u0430\u0443\u0446\u04370\u043E\u0430\u0437\u0446\u043E", "0\u043E\u0430\u04370", 9, 9 };
yield return new object[] { "abababababababababababababababbc", "bb", 29, 29 };
yield return new object[] { "abababababababababababababababb", "bb", 29, 29 };
yield return new object[] { "abababababababababababababababbc", "bb", 29, 29 };
yield return new object[] { "bbbbabababababababababababababababc", "aaa", -1, -1 };
yield return new object[] { "ababababababababababababababababbc", "abaa", -1, -1 };
yield return new object[] { "babbbabababababababababababababababc", "babb", 0, 0 };
- yield return new object[] { "babbbabababababababababababababababc", "сaсс", -1, -1 };
+ yield return new object[] { "babbbabababababababababababababababc", "\u0441a\u0441\u0441", -1, -1 };
yield return new object[] { "babbbbbbbbbbbbb", "babbbbbbbbbbbb", 0, 0 };
yield return new object[] { "babbbbbbbbbbbbbbabbbbbbbbbbbb", "babbbbbbbbbbbb", 0, 15 };
yield return new object[] { "babbbbbbbbbbbbbbbbabbbbbbbbbbbb", "babbbbbbbbbbbb", 0, 17 };
{
Assert.Equal("R. Daneel Olivaw", Name);
Assert.Equal(19_230, Age);
- Assert.Equal("Horní Dolní", PlaceOfBirth);
+ Assert.Equal("Horn\u00ED Doln\u00ED", PlaceOfBirth);
Assert.Null(Parent);
}
public static Person Create()
{
- return new Person { Name = "R. Daneel Olivaw", Age = 19_230, PlaceOfBirth = "Horní Dolní"};
+ return new Person { Name = "R. Daneel Olivaw", Age = 19_230, PlaceOfBirth = "Horn\u00ED Doln\u00ED"};
}
public string Serialize(JsonSerializerOptions options = null)
public void EncodeHeader_Base64Encoding_ShouldSplitBetweenCodepoints()
{
// header parts split by max line length in base64 encoding = 70 with respect to codepoints
- string headerPart1 = "Emoji subject : 🕐🕑🕒🕓🕔🕕";
- string headerPart2 = "🕖🕗🕘🕙🕚";
+ string headerPart1 = "Emoji subject : \uD83D\uDD50\uD83D\uDD51\uD83D\uDD52\uD83D\uDD53\uD83D\uDD54\uD83D\uDD55";
+ string headerPart2 = "\uD83D\uDD56\uD83D\uDD57\uD83D\uDD58\uD83D\uDD59\uD83D\uDD5A";
string longEmojiHeader = headerPart1 + headerPart2;
string encodedHeader = MimeBasePart.EncodeHeaderValue(longEmojiHeader, Encoding.UTF8, true);
public void EncodeHeader_QEncoding_ShouldSplitBetweenCodepoints()
{
// header parts split by max line length in q-encoding = 70 with respect to codepoints
- string headerPart1 = "Emoji subject : 🕐🕑🕒";
- string headerPart2 = "🕓🕔🕕🕖";
- string headerPart3 = "🕗🕘🕙🕚";
+ string headerPart1 = "Emoji subject : \uD83D\uDD50\uD83D\uDD51\uD83D\uDD52";
+ string headerPart2 = "\uD83D\uDD53\uD83D\uDD54\uD83D\uDD55\uD83D\uDD56";
+ string headerPart3 = "\uD83D\uDD57\uD83D\uDD58\uD83D\uDD59\uD83D\uDD5A";
string longEmojiHeader = headerPart1 + headerPart2 + headerPart3;
string encodedHeader = MimeBasePart.EncodeHeaderValue(longEmojiHeader, Encoding.UTF8, false);
}
[Theory]
- [InlineData(false, "🕐11111111111111111111111111111111111111111111:1111")]
- [InlineData(false, "🕐111111111111111111111111111111111111111111111:111")]
- [InlineData(false, "🕐1111111111111111111111111111111111111111111111:11")]
- [InlineData(false, "🕐11111111111111111111111111111111111111111\r\n1111")]
- [InlineData(false, "🕐111111111111111111111111111111111111111111\r\n111")]
- [InlineData(false, "🕐1111111111111111111111111111111111111111111\r\n11")]
- [InlineData(true, "Emoji subject : 🕐🕑🕒🕓🕔🕕:11111")]
- [InlineData(true, "Emoji subject : 🕐🕑🕒🕓🕔🕕\r\n11")]
+ [InlineData(false, "\uD83D\uDD5011111111111111111111111111111111111111111111:1111")]
+ [InlineData(false, "\uD83D\uDD50111111111111111111111111111111111111111111111:111")]
+ [InlineData(false, "\uD83D\uDD501111111111111111111111111111111111111111111111:11")]
+ [InlineData(false, "\uD83D\uDD5011111111111111111111111111111111111111111\r\n1111")]
+ [InlineData(false, "\uD83D\uDD50111111111111111111111111111111111111111111\r\n111")]
+ [InlineData(false, "\uD83D\uDD501111111111111111111111111111111111111111111\r\n11")]
+ [InlineData(true, "Emoji subject : \uD83D\uDD50\uD83D\uDD51\uD83D\uDD52\uD83D\uDD53\uD83D\uDD54\uD83D\uDD55:11111")]
+ [InlineData(true, "Emoji subject : \uD83D\uDD50\uD83D\uDD51\uD83D\uDD52\uD83D\uDD53\uD83D\uDD54\uD83D\uDD55\r\n11")]
public void EncodeString_IsSameAsEncodeBytes_IfOneByteCodepointOnLineWrap(bool useBase64Encoding, string value)
{
IEncodableStream streamForEncodeString = EncodedStreamFactory.GetEncoderForHeader(Encoding.UTF8, useBase64Encoding, 0);
/// <remarks>Euler's number is approximately 2.7182818284590452354.</remarks>
public const double E = Math.E;
- /// <summary>Represents the ratio of the circumference of a circle to its diameter, specified by the constant, π.</summary>
+ /// <summary>Represents the ratio of the circumference of a circle to its diameter, specified by the constant, PI.</summary>
/// <remarks>Pi is approximately 3.1415926535897932385.</remarks>
public const double Pi = Math.PI;
- /// <summary>Represents the number of radians in one turn, specified by the constant, τ.</summary>
+ /// <summary>Represents the number of radians in one turn, specified by the constant, Tau.</summary>
/// <remarks>Tau is approximately 6.2831853071795864769.</remarks>
public const double Tau = Math.Tau;
// Data for years 1960-2049 matches output of Calendrical Calculations [1] and published calendar tables [2].
// [1] Reingold, Edward M, and Nachum Dershowitz. Calendrical Calculations: The Ultimate Edition. Cambridge [etc.: Cambridge University Press, 2018. Print.
- // [2] Nishizawa, Yūsō. Rekijitsu Taikan: Meiji Kaireki 1873-Nen-2100-Nen Shinkyūreki, Kanshi Kyūsei Rokuyō Taishō. Tōkyō: Shin Jinbutsu Ōraisha, 1994. Print.
+ // [2] Nishizawa, Yu\u0304so\u0304. Rekijitsu Taikan: Meiji Kaireki 1873-Nen-2100-Nen Shinkyu\u0304reki, Kanshi Kyu\u0304sei Rokuyo\u0304 Taisho\u0304. To\u0304kyo\u0304: Shin Jinbutsu O\u0304raisha, 1994. Print.
private static readonly int[,] s_yinfo =
{
/*Y LM Lmon Lday DaysPerMonth D1 D2 D3 D4 D5 D6 D7 D8 D9 D10 D11 D12 D13 #Days
/// <summary>Returns the absolute value of a native signed integer.</summary>
/// <param name="value">A number that is greater than <see cref="IntPtr.MinValue" />, but less than or equal to <see cref="IntPtr.MaxValue" />.</param>
- /// <returns>A native signed integer, x, such that 0 ≤ x ≤ <see cref="IntPtr.MaxValue" />.</returns>
+ /// <returns>A native signed integer, x, such that 0 \u2264 x \u2264 <see cref="IntPtr.MaxValue" />.</returns>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static nint Abs(nint value)
{
/// <param name="min">The lower bound of the result.</param>
/// <param name="max">The upper bound of the result.</param>
/// <returns>
- /// <paramref name="value" /> if <paramref name="min" />
≤ <paramref name="value" /> ≤ <paramref name="max" />.
+ /// <paramref name="value" /> if <paramref name="min" />
\u2264 <paramref name="value" /> \u2264 <paramref name="max" />.
///
/// -or-
///
/// <param name="min">The lower bound of the result.</param>
/// <param name="max">The upper bound of the result.</param>
/// <returns>
- /// <paramref name="value" /> if <paramref name="min" />
≤ <paramref name="value" /> ≤ <paramref name="max" />.
+ /// <paramref name="value" /> if <paramref name="min" />
\u2264 <paramref name="value" /> \u2264 <paramref name="max" />.
///
/// -or-
///
/// <param name="y">The y-coordinate of a point.</param>
/// <param name="x">The x-coordinate of a point.</param>
/// <returns>The arc-tangent of <paramref name="y" /> divided-by <paramref name="x" />.</returns>
- /// <remarks>This computes <c>arctan(y / x)</c> in the interval <c>[-π, +π]</c> radians.</remarks>
+ /// <remarks>This computes <c>arctan(y / x)</c> in the interval <c>[-PI, +PI]</c> radians.</remarks>
static abstract TSelf Atan2(TSelf y, TSelf x);
/// <summary>Computes the arc-tangent for the quotient of two values and divides the result by <c>pi</c>.</summary>
/// <param name="y">The y-coordinate of a point.</param>
/// <param name="x">The x-coordinate of a point.</param>
/// <returns>The arc-tangent of <paramref name="y" /> divided-by <paramref name="x" />, divided by <c>pi</c>.</returns>
- /// <remarks>This computes <c>arctan(y / x) / π</c> in the interval <c>[-1, +1]</c>.</remarks>
+ /// <remarks>This computes <c>arctan(y / x) / PI</c> in the interval <c>[-1, +1]</c>.</remarks>
static abstract TSelf Atan2Pi(TSelf y, TSelf x);
/// <summary>Decrements a value to the largest value that compares less than a given value.</summary>
/// <summary>Computes the arc-cosine of a value.</summary>
/// <param name="x">The value whose arc-cosine is to be computed.</param>
/// <returns>The arc-cosine of <paramref name="x" />.</returns>
- /// <remarks>This computes <c>arccos(x)</c> in the interval <c>[+0, +π]</c> radians.</remarks>
+ /// <remarks>This computes <c>arccos(x)</c> in the interval <c>[+0, +PI]</c> radians.</remarks>
static abstract TSelf Acos(TSelf x);
/// <summary>Computes the arc-cosine of a value and divides the result by <c>pi</c>.</summary>
/// <param name="x">The value whose arc-cosine is to be computed.</param>
/// <returns>The arc-cosine of <paramref name="x" />, divided by <c>pi</c>.</returns>
- /// <remarks>This computes <c>arccos(x) / π</c> in the interval <c>[-0.5, +0.5]</c>.</remarks>
+ /// <remarks>This computes <c>arccos(x) / PI</c> in the interval <c>[-0.5, +0.5]</c>.</remarks>
static abstract TSelf AcosPi(TSelf x);
/// <summary>Computes the arc-sine of a value.</summary>
/// <param name="x">The value whose arc-sine is to be computed.</param>
/// <returns>The arc-sine of <paramref name="x" />.</returns>
- /// <remarks>This computes <c>arcsin(x)</c> in the interval <c>[-π / 2, +π / 2]</c> radians.</remarks>
+ /// <remarks>This computes <c>arcsin(x)</c> in the interval <c>[-PI / 2, +PI / 2]</c> radians.</remarks>
static abstract TSelf Asin(TSelf x);
/// <summary>Computes the arc-sine of a value and divides the result by <c>pi</c>.</summary>
/// <param name="x">The value whose arc-sine is to be computed.</param>
/// <returns>The arc-sine of <paramref name="x" />, divided by <c>pi</c>.</returns>
- /// <remarks>This computes <c>arcsin(x) / π</c> in the interval <c>[-0.5, +0.5]</c>.</remarks>
+ /// <remarks>This computes <c>arcsin(x) / PI</c> in the interval <c>[-0.5, +0.5]</c>.</remarks>
static abstract TSelf AsinPi(TSelf x);
/// <summary>Computes the arc-tangent of a value.</summary>
/// <param name="x">The value whose arc-tangent is to be computed.</param>
/// <returns>The arc-tangent of <paramref name="x" />.</returns>
- /// <remarks>This computes <c>arctan(x)</c> in the interval <c>[-π / 2, +π / 2]</c> radians.</remarks>
+ /// <remarks>This computes <c>arctan(x)</c> in the interval <c>[-PI / 2, +PI / 2]</c> radians.</remarks>
static abstract TSelf Atan(TSelf x);
/// <summary>Computes the arc-tangent of a value and divides the result by pi.</summary>
/// <param name="x">The value whose arc-tangent is to be computed.</param>
/// <returns>The arc-tangent of <paramref name="x" />, divided by <c>pi</c>.</returns>
- /// <remarks>This computes <c>arctan(x) / π</c> in the interval <c>[-0.5, +0.5]</c>.</remarks>
+ /// <remarks>This computes <c>arctan(x) / PI</c> in the interval <c>[-0.5, +0.5]</c>.</remarks>
static abstract TSelf AtanPi(TSelf x);
/// <summary>Computes the cosine of a value.</summary>
/// <summary>Computes the cosine of a value that has been multipled by <c>pi</c>.</summary>
/// <param name="x">The value, in half-revolutions, whose cosine is to be computed.</param>
/// <returns>The cosine of <paramref name="x" /> multiplied-by <c>pi</c>.</returns>
- /// <remarks>This computes <c>cos(x * π)</c>.</remarks>
+ /// <remarks>This computes <c>cos(x * PI)</c>.</remarks>
static abstract TSelf CosPi(TSelf x);
/// <summary>Computes the sine of a value.</summary>
/// <summary>Computes the sine and cosine of a value that has been multiplied by <c>pi</c>.</summary>
/// <param name="x">The value, in half-revolutions, that is multipled by <c>pi</c> before computing its sine and cosine.</param>
/// <returns>The sine and cosine of<paramref name="x" /> multiplied-by <c>pi</c>.</returns>
- /// <remarks>This computes <c>(sin(x * π), cos(x * π))</c>.</remarks>
+ /// <remarks>This computes <c>(sin(x * PI), cos(x * PI))</c>.</remarks>
static abstract (TSelf SinPi, TSelf CosPi) SinCosPi(TSelf x);
/// <summary>Computes the sine of a value that has been multiplied by <c>pi</c>.</summary>
/// <param name="x">The value, in half-revolutions, that is multipled by <c>pi</c> before computing its sine.</param>
/// <returns>The sine of <paramref name="x" /> multiplied-by <c>pi</c>.</returns>
- /// <remarks>This computes <c>sin(x * π)</c>.</remarks>
+ /// <remarks>This computes <c>sin(x * PI)</c>.</remarks>
static abstract TSelf SinPi(TSelf x);
/// <summary>Computes the tangent of a value.</summary>
/// <summary>Computes the tangent of a value that has been multipled by <c>pi</c>.</summary>
/// <param name="x">The value, in half-revolutions, that is multipled by <c>pi</c> before computing its tangent.</param>
/// <returns>The tangent of <paramref name="x" /> multiplied-by <c>pi</c>.</returns>
- /// <remarks>This computes <c>tan(x * π)</c>.</remarks>
+ /// <remarks>This computes <c>tan(x * PI)</c>.</remarks>
static abstract TSelf TanPi(TSelf x);
}
}
/// <remarks>This is known as Euler's number and is approximately 2.7182818284590452354.</remarks>
public const float E = MathF.E;
- /// <summary>Represents the ratio of the circumference of a circle to its diameter, specified by the constant, π.</summary>
+ /// <summary>Represents the ratio of the circumference of a circle to its diameter, specified by the constant, PI.</summary>
/// <remarks>Pi is approximately 3.1415926535897932385.</remarks>
public const float Pi = MathF.PI;
- /// <summary>Represents the number of radians in one turn, specified by the constant, τ.</summary>
+ /// <summary>Represents the number of radians in one turn, specified by the constant, Tau.</summary>
/// <remarks>Tau is approximately 6.2831853071795864769.</remarks>
public const float Tau = MathF.Tau;
}
return -1;
- // Based on http://0x80.pl/articles/simd-strfind.html#algorithm-1-generic-simd "Algorithm 1: Generic SIMD" by Wojciech Muła
+ // Based on http://0x80.pl/articles/simd-strfind.html#algorithm-1-generic-simd "Algorithm 1: Generic SIMD" by Wojciech Mula
// Some details about the implementation can also be found in https://github.com/dotnet/runtime/pull/63285
SEARCH_TWO_BYTES:
if (Vector256.IsHardwareAccelerated && searchSpaceMinusValueTailLength - Vector256<byte>.Count >= 0)
}
return -1;
- // Based on http://0x80.pl/articles/simd-strfind.html#algorithm-1-generic-simd "Algorithm 1: Generic SIMD" by Wojciech Muła
+ // Based on http://0x80.pl/articles/simd-strfind.html#algorithm-1-generic-simd "Algorithm 1: Generic SIMD" by Wojciech Mula
// Some details about the implementation can also be found in https://github.com/dotnet/runtime/pull/63285
SEARCH_TWO_BYTES:
if (Vector256.IsHardwareAccelerated && searchSpaceMinusValueTailLength >= Vector256<byte>.Count)
}
return -1;
- // Based on http://0x80.pl/articles/simd-strfind.html#algorithm-1-generic-simd "Algorithm 1: Generic SIMD" by Wojciech Muła
+ // Based on http://0x80.pl/articles/simd-strfind.html#algorithm-1-generic-simd "Algorithm 1: Generic SIMD" by Wojciech Mula
// Some details about the implementation can also be found in https://github.com/dotnet/runtime/pull/63285
SEARCH_TWO_CHARS:
ref ushort ushortSearchSpace = ref Unsafe.As<char, ushort>(ref searchSpace);
}
return -1;
- // Based on http://0x80.pl/articles/simd-strfind.html#algorithm-1-generic-simd "Algorithm 1: Generic SIMD" by Wojciech Muła
+ // Based on http://0x80.pl/articles/simd-strfind.html#algorithm-1-generic-simd "Algorithm 1: Generic SIMD" by Wojciech Mula
// Some details about the implementation can also be found in https://github.com/dotnet/runtime/pull/63285
SEARCH_TWO_CHARS:
ref ushort ushortSearchSpace = ref Unsafe.As<char, ushort>(ref searchSpace);
public class PercentEncodingHelperTests
{
private const string OneByteUtf8 = "%41"; // A
- private const string TwoByteUtf8 = "%C3%BC"; // ü
- private const string ThreeByteUtf8 = "%E8%AF%B6"; // 诶
- private const string FourByteUtf8 = "%F0%9F%98%80"; // 😀
+ private const string TwoByteUtf8 = "%C3%BC"; // \u00FC
+ private const string ThreeByteUtf8 = "%E8%AF%B6"; // \u8BF6
+ private const string FourByteUtf8 = "%F0%9F%98%80"; // \uD83D\uDE00
private const string InvalidOneByteUtf8 = "%FF";
private const string OverlongTwoByteUtf8 = "%C1%81"; // A
- private const string OverlongThreeByteUtf8 = "%E0%83%BC"; // ü
- private const string OverlongFourByteUtf8 = "%F0%88%AF%B6"; // 诶;
+ private const string OverlongThreeByteUtf8 = "%E0%83%BC"; // \u00FC
+ private const string OverlongFourByteUtf8 = "%F0%88%AF%B6"; // \u8BF6;
public static IEnumerable<object[]> PercentEncodedAndDecodedUTF8Sequences()
{
static object[] Pair(string s1, string s2) => new object[] { s1, s2 };
yield return Pair(OneByteUtf8, "A");
- yield return Pair(TwoByteUtf8, "ü");
- yield return Pair(ThreeByteUtf8, "诶");
- yield return Pair(FourByteUtf8, "😀");
+ yield return Pair(TwoByteUtf8, "\u00FC");
+ yield return Pair(ThreeByteUtf8, "\u8BF6");
+ yield return Pair(FourByteUtf8, "\uD83D\uDE00");
yield return Pair(OneByteUtf8 + OneByteUtf8, "AA");
- yield return Pair(TwoByteUtf8 + TwoByteUtf8, "üü");
- yield return Pair(ThreeByteUtf8 + ThreeByteUtf8, "诶诶");
- yield return Pair(FourByteUtf8 + FourByteUtf8, "😀😀");
+ yield return Pair(TwoByteUtf8 + TwoByteUtf8, "\u00FC\u00FC");
+ yield return Pair(ThreeByteUtf8 + ThreeByteUtf8, "\u8BF6\u8BF6");
+ yield return Pair(FourByteUtf8 + FourByteUtf8, "\uD83D\uDE00\uD83D\uDE00");
- yield return Pair(OneByteUtf8 + TwoByteUtf8 + OneByteUtf8, "AüA");
- yield return Pair(TwoByteUtf8 + ThreeByteUtf8 + TwoByteUtf8, "ü诶ü");
+ yield return Pair(OneByteUtf8 + TwoByteUtf8 + OneByteUtf8, "A\u00FCA");
+ yield return Pair(TwoByteUtf8 + ThreeByteUtf8 + TwoByteUtf8, "\u00FC\u8BF6\u00FC");
yield return Pair(InvalidOneByteUtf8 + OneByteUtf8, InvalidOneByteUtf8 + "A");
- yield return Pair(OverlongTwoByteUtf8 + TwoByteUtf8, OverlongTwoByteUtf8 + "ü");
- yield return Pair(OverlongThreeByteUtf8 + ThreeByteUtf8, OverlongThreeByteUtf8 + "诶");
- yield return Pair(OverlongFourByteUtf8 + FourByteUtf8, OverlongFourByteUtf8 + "😀");
+ yield return Pair(OverlongTwoByteUtf8 + TwoByteUtf8, OverlongTwoByteUtf8 + "\u00FC");
+ yield return Pair(OverlongThreeByteUtf8 + ThreeByteUtf8, OverlongThreeByteUtf8 + "\u8BF6");
+ yield return Pair(OverlongFourByteUtf8 + FourByteUtf8, OverlongFourByteUtf8 + "\uD83D\uDE00");
yield return Pair(InvalidOneByteUtf8, InvalidOneByteUtf8);
yield return Pair(InvalidOneByteUtf8 + InvalidOneByteUtf8, InvalidOneByteUtf8 + InvalidOneByteUtf8);
yield return Pair(InvalidOneByteUtf8 + InvalidOneByteUtf8 + InvalidOneByteUtf8, InvalidOneByteUtf8 + InvalidOneByteUtf8 + InvalidOneByteUtf8);
// 11001010 11100100 10001000 10110010 - 2-byte marker followed by 3-byte sequence
- yield return Pair("%CA" + "%E4%88%B2", "%CA" + '䈲');
+ yield return Pair("%CA" + "%E4%88%B2", "%CA" + '\u4232');
// 4 valid UTF8 bytes followed by 5 invalid UTF8 bytes
yield return Pair("%F4%80%80%BA" + "%FD%80%80%BA%CD", "\U0010003A" + "%FD%80%80%BA%CD");
// Char Block: 3400..4DBF-CJK Unified Ideographs Extension A
yield return Pair("%E4%88%B2", "\u4232");
- // BIDI char followed by a valid 3-byte UTF8 sequence (ク)
- yield return Pair("%E2%80%8E" + "%E3%82%AF", "\u200E" + "ク");
+ // BIDI char followed by a valid 3-byte UTF8 sequence (\u30AF)
+ yield return Pair("%E2%80%8E" + "%E3%82%AF", "\u200E" + "\u30AF");
// BIDI char followed by invalid UTF8 bytes
yield return Pair("%E2%80%8E" + "%F0%90%90", "\u200E" + "%F0%90%90");
// Input string: %98%C8%D4%F3 %D4%A8 %7A %CF%DE %41 %16
// Valid Unicode sequences: %D4%A8 %7A %41 %16
yield return Pair("%98%C8%D4%F3" + "%D4%A8" + "%7A" + "%CF%DE" + "%41" + "%16",
- "%98%C8%D4%F3" + 'Ԩ' + 'z' + "%CF%DE" + 'A' + '\x16');
+ "%98%C8%D4%F3" + '\u0528' + 'z' + "%CF%DE" + 'A' + '\x16');
// 2-byte marker, valid 4-byte sequence, continuation byte
yield return Pair("%C6" + "%F3%BC%A1%B8" + "%B5",
{
XmlSchema schema = new XmlSchema();
- string expectedSchema = @"<?xml version=""1.0"" encoding=""utf-8""?><xs:schema xmlns:xs=""http://www.w3.org/2001/XMLSchema""><xs:element name=""cat"" type=""xs:string"" /><xs:element name=""dog"" type=""xs:string"" /><xs:element name=""redDog"" substitutionGroup=""dog"" /><xs:element name=""brownDog"" substitutionGroup=""dog"" /><xs:element name=""pets"" /></xs:schema>";
+ string BOMString = Encoding.UTF8.GetString(Encoding.UTF8.GetPreamble());
+ string expectedSchema = BOMString + @"<?xml version=""1.0"" encoding=""utf-8""?><xs:schema xmlns:xs=""http://www.w3.org/2001/XMLSchema""><xs:element name=""cat"" type=""xs:string"" /><xs:element name=""dog"" type=""xs:string"" /><xs:element name=""redDog"" substitutionGroup=""dog"" /><xs:element name=""brownDog"" substitutionGroup=""dog"" /><xs:element name=""pets"" /></xs:schema>";
// <xs:element name="cat" type="xs:string"/>
XmlSchemaElement elementCat = new XmlSchemaElement();
yield return new object[] { Encoding.Unicode.GetBytes("vbnmbbbbccccdddddddeeeeeaaaabbbbccccdddddddeeeeeaaaabbbbccccddx"), "dgBiAG4AbQBiAGIAYgBiAGMAYwBjAGMAZABkAGQAZABkAGQAZABlAGUAZQBlAGUAYQBhAGEAYQBiAGIAYgBiAGMAYwBjAGMAZABkAGQAZABkAGQAZABlAGUAZQBlAGUAYQBhAGEAYQBiAGIAYgBiAGMAYwBjAGMAZABkAHgA" };
yield return new object[] { Encoding.Unicode.GetBytes("rrrrbbbbccccdddddddeeeeeaaaabbbbccccdddddddeeeeeaaaabbbbccccdd\0"), "cgByAHIAcgBiAGIAYgBiAGMAYwBjAGMAZABkAGQAZABkAGQAZABlAGUAZQBlAGUAYQBhAGEAYQBiAGIAYgBiAGMAYwBjAGMAZABkAGQAZABkAGQAZABlAGUAZQBlAGUAYQBhAGEAYQBiAGIAYgBiAGMAYwBjAGMAZABkAAAA" };
yield return new object[] { Encoding.Unicode.GetBytes("uuuubbbbccccdddddddeeeeeaaaabbbbccccdddddddeeeeeaaaabbbbccccdd\0feffe"), "dQB1AHUAdQBiAGIAYgBiAGMAYwBjAGMAZABkAGQAZABkAGQAZABlAGUAZQBlAGUAYQBhAGEAYQBiAGIAYgBiAGMAYwBjAGMAZABkAGQAZABkAGQAZABlAGUAZQBlAGUAYQBhAGEAYQBiAGIAYgBiAGMAYwBjAGMAZABkAAAAZgBlAGYAZgBlAA==" };
- yield return new object[] { Encoding.Unicode.GetBytes("kkkkkbbbbccccdddddddeeeeeaaaabbbbccccdddddddeeeeeaaaabbbbccccddxприветмир你好世界"), "awBrAGsAawBrAGIAYgBiAGIAYwBjAGMAYwBkAGQAZABkAGQAZABkAGUAZQBlAGUAZQBhAGEAYQBhAGIAYgBiAGIAYwBjAGMAYwBkAGQAZABkAGQAZABkAGUAZQBlAGUAZQBhAGEAYQBhAGIAYgBiAGIAYwBjAGMAYwBkAGQAeAA/BEAEOAQyBDUEQgQ8BDgEQARgT31ZFk5MdQ==" };
- yield return new object[] { Encoding.Unicode.GetBytes(",,,,bbbbccccdddddddeeeeeaaaabbbbccccdddddddeeeeeaaaabbbbccccddxприветмир你好世界ddddeeeeea"), "LAAsACwALABiAGIAYgBiAGMAYwBjAGMAZABkAGQAZABkAGQAZABlAGUAZQBlAGUAYQBhAGEAYQBiAGIAYgBiAGMAYwBjAGMAZABkAGQAZABkAGQAZABlAGUAZQBlAGUAYQBhAGEAYQBiAGIAYgBiAGMAYwBjAGMAZABkAHgAPwRABDgEMgQ1BEIEPAQ4BEAEYE99WRZOTHVkAGQAZABkAGUAZQBlAGUAZQBhAA==" };
+ yield return new object[] { Encoding.Unicode.GetBytes("kkkkkbbbbccccdddddddeeeeeaaaabbbbccccdddddddeeeeeaaaabbbbccccddx\u043F\u0440\u0438\u0432\u0435\u0442\u043C\u0438\u0440\u4F60\u597D\u4E16\u754C"), "awBrAGsAawBrAGIAYgBiAGIAYwBjAGMAYwBkAGQAZABkAGQAZABkAGUAZQBlAGUAZQBhAGEAYQBhAGIAYgBiAGIAYwBjAGMAYwBkAGQAZABkAGQAZABkAGUAZQBlAGUAZQBhAGEAYQBhAGIAYgBiAGIAYwBjAGMAYwBkAGQAeAA/BEAEOAQyBDUEQgQ8BDgEQARgT31ZFk5MdQ==" };
+ yield return new object[] { Encoding.Unicode.GetBytes(",,,,bbbbccccdddddddeeeeeaaaabbbbccccdddddddeeeeeaaaabbbbccccddx\u043F\u0440\u0438\u0432\u0435\u0442\u043C\u0438\u0440\u4F60\u597D\u4E16\u754Cddddeeeeea"), "LAAsACwALABiAGIAYgBiAGMAYwBjAGMAZABkAGQAZABkAGQAZABlAGUAZQBlAGUAYQBhAGEAYQBiAGIAYgBiAGMAYwBjAGMAZABkAGQAZABkAGQAZABlAGUAZQBlAGUAYQBhAGEAYQBiAGIAYgBiAGMAYwBjAGMAZABkAHgAPwRABDgEMgQ1BEIEPAQ4BEAEYE99WRZOTHVkAGQAZABkAGUAZQBlAGUAZQBhAA==" };
yield return new object[] { Encoding.Unicode.GetBytes("____bbbbccccdddddddeeeeeaaaabbbbccccdddddddeeeeeaaaabbbbccccddaaaabbbbccccdddddddeeeeeaaaabbbbccccdcccd"), "XwBfAF8AXwBiAGIAYgBiAGMAYwBjAGMAZABkAGQAZABkAGQAZABlAGUAZQBlAGUAYQBhAGEAYQBiAGIAYgBiAGMAYwBjAGMAZABkAGQAZABkAGQAZABlAGUAZQBlAGUAYQBhAGEAYQBiAGIAYgBiAGMAYwBjAGMAZABkAGEAYQBhAGEAYgBiAGIAYgBjAGMAYwBjAGQAZABkAGQAZABkAGQAZQBlAGUAZQBlAGEAYQBhAGEAYgBiAGIAYgBjAGMAYwBjAGQAYwBjAGMAZAA=" };
yield return new object[] { Encoding.Unicode.GetBytes(" bbbbccccdddddddeeeeeaaaabbbbccccdddddddeeeeeaaaabbbbccccddaaaabbbbccccdddddddeeeeeaaaabbbbccccdddddddeeeeeaaaabbbbccccd"), "IAAgACAAIABiAGIAYgBiAGMAYwBjAGMAZABkAGQAZABkAGQAZABlAGUAZQBlAGUAYQBhAGEAYQBiAGIAYgBiAGMAYwBjAGMAZABkAGQAZABkAGQAZABlAGUAZQBlAGUAYQBhAGEAYQBiAGIAYgBiAGMAYwBjAGMAZABkAGEAYQBhAGEAYgBiAGIAYgBjAGMAYwBjAGQAZABkAGQAZABkAGQAZQBlAGUAZQBlAGEAYQBhAGEAYgBiAGIAYgBjAGMAYwBjAGQAZABkAGQAZABkAGQAZQBlAGUAZQBlAGEAYQBhAGEAYgBiAGIAYgBjAGMAYwBjAGQA" };
yield return new object[] { Encoding.Unicode.GetBytes("\0\0bbbbccccdddddddeeeeeaaaabbbbccccdddddddeeeeeaaaabbbbccccddaaaabbbbccccdddddddeeeeeaaaabbbbccccdddddddeeeeeaaaabbbbccccddx"), "AAAAAGIAYgBiAGIAYwBjAGMAYwBkAGQAZABkAGQAZABkAGUAZQBlAGUAZQBhAGEAYQBhAGIAYgBiAGIAYwBjAGMAYwBkAGQAZABkAGQAZABkAGUAZQBlAGUAZQBhAGEAYQBhAGIAYgBiAGIAYwBjAGMAYwBkAGQAYQBhAGEAYQBiAGIAYgBiAGMAYwBjAGMAZABkAGQAZABkAGQAZABlAGUAZQBlAGUAYQBhAGEAYQBiAGIAYgBiAGMAYwBjAGMAZABkAGQAZABkAGQAZABlAGUAZQBlAGUAYQBhAGEAYQBiAGIAYgBiAGMAYwBjAGMAZABkAHgA" };
{
yield return new object[] { (char)42 };
yield return new object[] { (char)1 };
- yield return new object[] { 'Ž' };
- yield return new object[] { '♡' };
+ yield return new object[] { '\u017D' };
+ yield return new object[] { '\u2661' };
yield return new object[] { char.MaxValue };
yield return new object[] { char.MinValue };
}
return new []
{
"ABCdef 123$%^",
- "🍜 !! 🍜 !!",
- "🌲 木 🔥 火 🌾 土 🛡 金 🌊 水" ,
+ "\uD83C\uDF5C !! \uD83C\uDF5C !!",
+ "\uD83C\uDF32 \u6728 \uD83D\uDD25 \u706B \uD83C\uDF3E \u571F \uD83D\uDEE1 \u91D1 \uD83C\uDF0A \u6C34" ,
"Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed vitae posuere mauris, sed ultrices leo. Suspendisse potenti. Mauris enim enim, blandit tincidunt consequat in, varius sit amet neque. Morbi eget porttitor ex. Duis mattis aliquet ante quis imperdiet. Duis sit.",
string.Empty,
null
yield return new object[] { 'A', 0x41 };
yield return new object[] { 'E', 0x45 };
yield return new object[] { 'J', 0x4a };
- yield return new object[] { 'ß', 0xdf };
- yield return new object[] { '✅', 0x2705 };
- yield return new object[] { '鸟', 0x9e1f };
+ yield return new object[] { '\u00DF', 0xdf };
+ yield return new object[] { '\u2705', 0x2705 };
+ yield return new object[] { '\u9E1F', 0x9e1f };
}
[Theory]
public static IEnumerable<object[]> UnicodeStrings() => new []
{
new object[] { "ABCdef 123$%^" },
- new object[] { "🍜 !! 🍜 !!"},
- new object[] { "🌲 木 🔥 火 🌾 土 🛡 金 🌊 水" },
+ new object[] { "\uD83C\uDF5C !! \uD83C\uDF5C !!"},
+ new object[] { "\uD83C\uDF32 \u6728 \uD83D\uDD25 \u706B \uD83C\uDF3E \u571F \uD83D\uDEE1 \u91D1 \uD83C\uDF0A \u6C34" },
new object[] { "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed vitae posuere mauris, sed ultrices leo. Suspendisse potenti. Mauris enim enim, blandit tincidunt consequat in, varius sit amet neque. Morbi eget porttitor ex. Duis mattis aliquet ante quis imperdiet. Duis sit." },
new object[] { string.Empty },
new object[] { null },
}
NumberFormatInfo invariantFormat = NumberFormatInfo.InvariantInfo;
- yield return new object[] { (byte)32, "C100", invariantFormat, "¤32.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" };
+ yield return new object[] { (byte)32, "C100", invariantFormat, "\u00A432.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" };
yield return new object[] { (byte)32, "P100", invariantFormat, "3,200.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 %" };
yield return new object[] { (byte)32, "D100", invariantFormat, "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000032" };
yield return new object[] { (byte)32, "E100", invariantFormat, "3.2000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000E+001" };
}
NumberFormatInfo invariantFormat = NumberFormatInfo.InvariantInfo;
- yield return new object[] { 32.5m, "C100", invariantFormat, "¤32.5000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" };
+ yield return new object[] { 32.5m, "C100", invariantFormat, "\u00A432.5000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" };
yield return new object[] { 32.5m, "P100", invariantFormat, "3,250.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 %" };
yield return new object[] { 32.5m, "E100", invariantFormat, "3.2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000E+001" };
yield return new object[] { 32.5m, "F100", invariantFormat, "32.5000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" };
NumberFormatInfo invariantFormat = NumberFormatInfo.InvariantInfo;
yield return new object[] { double.Epsilon, "G", invariantFormat, "5E-324" };
- yield return new object[] { 32.5, "C100", invariantFormat, "¤32.5000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" };
+ yield return new object[] { 32.5, "C100", invariantFormat, "\u00A432.5000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" };
yield return new object[] { 32.5, "P100", invariantFormat, "3,250.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 %" };
yield return new object[] { 32.5, "E100", invariantFormat, "3.2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000E+001" };
yield return new object[] { 32.5, "F100", invariantFormat, "32.5000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" };
NumberFormatInfo invariantFormat = NumberFormatInfo.InvariantInfo;
yield return new object[] { Half.Epsilon, "G", invariantFormat, "6E-08" };
- yield return new object[] { 32.5f, "C100", invariantFormat, "¤32.5000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" };
+ yield return new object[] { 32.5f, "C100", invariantFormat, "\u00A432.5000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" };
yield return new object[] { 32.5f, "P100", invariantFormat, "3,250.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 %" };
yield return new object[] { 32.5f, "E100", invariantFormat, "3.2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000E+001" };
yield return new object[] { 32.5f, "F100", invariantFormat, "32.5000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" };
}
NumberFormatInfo invariantFormat = NumberFormatInfo.InvariantInfo;
- yield return new object[] { (Int128)32, "C100", invariantFormat, "¤32.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" };
+ yield return new object[] { (Int128)32, "C100", invariantFormat, "\u00A432.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" };
yield return new object[] { (Int128)32, "P100", invariantFormat, "3,200.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 %" };
yield return new object[] { (Int128)32, "D100", invariantFormat, "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000032" };
yield return new object[] { (Int128)32, "E100", invariantFormat, "3.2000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000E+001" };
}
NumberFormatInfo invariantFormat = NumberFormatInfo.InvariantInfo;
- yield return new object[] { (short)32, "C100", invariantFormat, "¤32.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" };
+ yield return new object[] { (short)32, "C100", invariantFormat, "\u00A432.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" };
yield return new object[] { (short)32, "P100", invariantFormat, "3,200.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 %" };
yield return new object[] { (short)32, "D100", invariantFormat, "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000032" };
yield return new object[] { (short)32, "E100", invariantFormat, "3.2000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000E+001" };
}
NumberFormatInfo invariantFormat = NumberFormatInfo.InvariantInfo;
- yield return new object[] { 32, "C100", invariantFormat, "¤32.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" };
+ yield return new object[] { 32, "C100", invariantFormat, "\u00A432.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" };
yield return new object[] { 32, "P100", invariantFormat, "3,200.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 %" };
yield return new object[] { 32, "D100", invariantFormat, "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000032" };
yield return new object[] { 32, "E100", invariantFormat, "3.2000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000E+001" };
}
NumberFormatInfo invariantFormat = NumberFormatInfo.InvariantInfo;
- yield return new object[] { (long)32, "C100", invariantFormat, "¤32.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" };
+ yield return new object[] { (long)32, "C100", invariantFormat, "\u00A432.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" };
yield return new object[] { (long)32, "P100", invariantFormat, "3,200.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 %" };
yield return new object[] { (long)32, "D100", invariantFormat, "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000032" };
yield return new object[] { (long)32, "E100", invariantFormat, "3.2000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000E+001" };
}
NumberFormatInfo invariantFormat = NumberFormatInfo.InvariantInfo;
- yield return new object[] { (sbyte)32, "C100", invariantFormat, "¤32.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" };
+ yield return new object[] { (sbyte)32, "C100", invariantFormat, "\u00A432.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" };
yield return new object[] { (sbyte)32, "P100", invariantFormat, "3,200.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 %" };
yield return new object[] { (sbyte)32, "D100", invariantFormat, "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000032" };
yield return new object[] { (sbyte)32, "E100", invariantFormat, "3.2000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000E+001" };
NumberFormatInfo invariantFormat = NumberFormatInfo.InvariantInfo;
yield return new object[] { float.Epsilon, "G", invariantFormat, "1E-45" };
- yield return new object[] { 32.5f, "C100", invariantFormat, "¤32.5000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" };
+ yield return new object[] { 32.5f, "C100", invariantFormat, "\u00A432.5000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" };
yield return new object[] { 32.5f, "P100", invariantFormat, "3,250.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 %" };
yield return new object[] { 32.5f, "E100", invariantFormat, "3.2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000E+001" };
yield return new object[] { 32.5f, "F100", invariantFormat, "32.5000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" };
string source = "Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh " +
"Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh " +
"Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh " +
- "сентября Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh " +
+ "\u0441\u0435\u043D\u0442\u044F\u0431\u0440\u044F Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh " +
"Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh " +
"Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh Abcdefgh ";
- string source1 = "сентября Abcdefgh сентября ";
+ string source1 = "\u0441\u0435\u043D\u0442\u044F\u0431\u0440\u044F Abcdefgh \u0441\u0435\u043D\u0442\u044F\u0431\u0440\u044F ";
- string pattern = "сентября ";
- string pattern1 = "сентябряnone";
+ string pattern = "\u0441\u0435\u043D\u0442\u044F\u0431\u0440\u044F ";
+ string pattern1 = "\u0441\u0435\u043D\u0442\u044F\u0431\u0440\u044Fnone";
CompareInfo ci = CultureInfo.CurrentCulture.CompareInfo;
}
NumberFormatInfo invariantFormat = NumberFormatInfo.InvariantInfo;
- yield return new object[] { (UInt128)32, "C100", invariantFormat, "¤32.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" };
+ yield return new object[] { (UInt128)32, "C100", invariantFormat, "\u00A432.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" };
yield return new object[] { (UInt128)32, "P100", invariantFormat, "3,200.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 %" };
yield return new object[] { (UInt128)32, "D100", invariantFormat, "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000032" };
yield return new object[] { (UInt128)32, "E100", invariantFormat, "3.2000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000E+001" };
}
NumberFormatInfo invariantFormat = NumberFormatInfo.InvariantInfo;
- yield return new object[] { (ushort)32, "C100", invariantFormat, "¤32.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" };
+ yield return new object[] { (ushort)32, "C100", invariantFormat, "\u00A432.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" };
yield return new object[] { (ushort)32, "P100", invariantFormat, "3,200.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 %" };
yield return new object[] { (ushort)32, "D100", invariantFormat, "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000032" };
yield return new object[] { (ushort)32, "E100", invariantFormat, "3.2000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000E+001" };
}
NumberFormatInfo invariantFormat = NumberFormatInfo.InvariantInfo;
- yield return new object[] { (uint)32, "C100", invariantFormat, "¤32.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" };
+ yield return new object[] { (uint)32, "C100", invariantFormat, "\u00A432.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" };
yield return new object[] { (uint)32, "P100", invariantFormat, "3,200.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 %" };
yield return new object[] { (uint)32, "D100", invariantFormat, "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000032" };
yield return new object[] { (uint)32, "E100", invariantFormat, "3.2000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000E+001" };
}
NumberFormatInfo invariantFormat = NumberFormatInfo.InvariantInfo;
- yield return new object[] { (ulong)32, "C100", invariantFormat, "¤32.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" };
+ yield return new object[] { (ulong)32, "C100", invariantFormat, "\u00A432.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" };
yield return new object[] { (ulong)32, "P100", invariantFormat, "3,200.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 %" };
yield return new object[] { (ulong)32, "D100", invariantFormat, "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000032" };
yield return new object[] { (ulong)32, "E100", invariantFormat, "3.2000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000E+001" };
SampleEnumUInt32 enum5 = SampleEnumUInt32.MinZero,
string str1 = "abc",
string str2 = "",
- string str3 = "\n\r⁉️\'\"\u200D\f\t\v\0\a\b\\\'\"",
+ string str3 = "\n\r\u2049\uFE0F\'\"\u200D\f\t\v\0\a\b\\\'\"",
char char1 = 'a',
char char2 = '\u200D',
double double1 = double.NegativeInfinity,
Schema = 2,
SmtpId = 3,
Emojies = 4,
- ꀀ = 5,
+ \uA000 = 5,
YiIt_2 = 6
};
Assert.Equal(2, obj.Schema);
Assert.Equal(3, obj.SmtpId);
Assert.Equal(4, obj.Emojies);
- Assert.Equal(5, obj.ꀀ);
+ Assert.Equal(5, obj.\uA000);
Assert.Equal(6, obj.YiIt_2);
}
public int SmtpId { get; set; }
[JsonPropertyOrder(4)]
- [JsonPropertyName("😀😁")] // Invalid C# property name. Unicode:\uD83D\uDE00\uD83D\uDE01
+ [JsonPropertyName("\uD83D\uDE00\uD83D\uDE01")] // Invalid C# property name. Unicode:\uD83D\uDE00\uD83D\uDE01
public int Emojies { get; set; }
[JsonPropertyOrder(5)]
- public int ꀀ { get; set; } // Valid C# property name. Unicode:\uA000
+ public int \uA000 { get; set; } // Valid C# property name. Unicode:\uA000
[JsonPropertyOrder(6)]
- [JsonPropertyName("\uA000_2")] // Valid C# property name: ꀀ_2
+ [JsonPropertyName("\uA000_2")] // Valid C# property name: \uA000_2
public int YiIt_2 { get; set; }
}
}
for (int i = 1; i < maxLength - 1; i++)
{
- sb.Append('的'); // Non-UTF-8 character than will expand during transcoding
+ sb.Append('\u7684'); // Non-UTF-8 character than will expand during transcoding
}
sb.Append('"');
protected override void InitTrackCount() => base.runtrackcount = 12;
// Description:
- // ○ Match if at the start position.
- // ○ 1st capture group.
- // ○ Match a Unicode digit greedily at least 1 and at most 3 times.
- // ○ Zero-width positive lookahead assertion.
- // ○ Loop greedily at least once.
- // ○ Match a Unicode digit exactly 3 times.
- // ○ Match if at a word boundary.
+ // * Match if at the start position.
+ // * 1st capture group.
+ // * Match a Unicode digit greedily at least 1 and at most 3 times.
+ // * Zero-width positive lookahead assertion.
+ // * Loop greedily at least once.
+ // * Match a Unicode digit exactly 3 times.
+ // * Match if at a word boundary.
protected override bool FindFirstChar()
{
yield return new object[] { engine, @".", "\n\n\n", 0, RegexOptions.None, 0 };
yield return new object[] { engine, @".", "\n\n\n", 0, RegexOptions.Singleline, 3 };
- yield return new object[] { engine, @"[а-я-[аeиоуыэюя]]", "спокойной ночи", 0, RegexOptions.None, 8 };
+ yield return new object[] { engine, @"[\u0430-\u044F-[\u0430e\u0438\u043E\u0443\u044B\u044D\u044E\u044F]]", "\u0441\u043F\u043E\u043A\u043E\u0439\u043D\u043E\u0439 \u043D\u043E\u0447\u0438", 0, RegexOptions.None, 8 };
if (!RegexHelpers.IsNonBacktracking(engine))
{
RegexOptions options = RegexOptions.NonBacktracking;
// pattern and its expected safe size
- // all patterns have an implicit 0-start-capture node ⌊₀ and
- // 0-end-capture node ⁰⌉ and thus also two extra cocatenation nodes
+ // all patterns have an implicit 0-start-capture node \u230A\u2080 and
+ // 0-end-capture node \u2070\u2309 and thus also two extra cocatenation nodes
// let the safe size of a pattern X be denoted by #(X)
(string, int)[] patternData = new (string, int)[]{
// no singletons
// Authors:
// Patrik Torstensson (Patrik.Torstensson@labs2.com)
-// Wictor Wilén (decode/encode functions) (wictor@ibizkit.se)
+// Wictor Wil\u00E9n (decode/encode functions) (wictor@ibizkit.se)
// Tim Coleman (tim@timcoleman.com)
// Gonzalo Paniagua Javier (gonzalo@ximian.com)
//
//test strings
public static string[] utf8Strings = {
"Managed",
- "Sîne klâwen durh die wolken sint geslagen" ,
- "काचं शक्नोम्यत्तुम् । नोपहिनस्ति माम्",
- "我能吞下玻璃而不伤身体",
- "ღმერთსი შემვედრე,შემვედრე, ნუთუ კვლა დამხსნას შემვედრე,სოფლისა შემვედრე, შემვედრე,შემვედრე,შემვედრე,შრომასა, ცეცხლს, წყალსა და მიწასა, ჰაერთა თანა მრომასა; მომცნეს ფრთენი და აღვფრინდე, მივჰხვდე მას ჩემსა ნდომასა, დღისით და ღამით ვჰხედვიდე მზისა ელვათა კრთომაასაშემვედრე,შემვედრე,",
- "Τη γλώσσα μου έδωσαν ελληνική",
+ "S\u00EEne kl\u00E2wen durh die wolken sint geslagen" ,
+ "\u0915\u093E\u091A\u0902 \u0936\u0915\u094D\u0928\u094B\u092E\u094D\u092F\u0924\u094D\u0924\u0941\u092E\u094D \u0964 \u0928\u094B\u092A\u0939\u093F\u0928\u0938\u094D\u0924\u093F \u092E\u093E\u092E\u094D",
+ "\u6211\u80FD\u541E\u4E0B\u73BB\u7483\u800C\u4E0D\u4F24\u8EAB\u4F53",
+ "\u10E6\u10DB\u10D4\u10E0\u10D7\u10E1\u10D8 \u10E8\u10D4\u10DB\u10D5\u10D4\u10D3\u10E0\u10D4,\u10E8\u10D4\u10DB\u10D5\u10D4\u10D3\u10E0\u10D4, \u10DC\u10E3\u10D7\u10E3 \u10D9\u10D5\u10DA\u10D0 \u10D3\u10D0\u10DB\u10EE\u10E1\u10DC\u10D0\u10E1 \u10E8\u10D4\u10DB\u10D5\u10D4\u10D3\u10E0\u10D4,\u10E1\u10DD\u10E4\u10DA\u10D8\u10E1\u10D0 \u10E8\u10D4\u10DB\u10D5\u10D4\u10D3\u10E0\u10D4, \u10E8\u10D4\u10DB\u10D5\u10D4\u10D3\u10E0\u10D4,\u10E8\u10D4\u10DB\u10D5\u10D4\u10D3\u10E0\u10D4,\u10E8\u10D4\u10DB\u10D5\u10D4\u10D3\u10E0\u10D4,\u10E8\u10E0\u10DD\u10DB\u10D0\u10E1\u10D0, \u10EA\u10D4\u10EA\u10EE\u10DA\u10E1, \u10EC\u10E7\u10D0\u10DA\u10E1\u10D0 \u10D3\u10D0 \u10DB\u10D8\u10EC\u10D0\u10E1\u10D0, \u10F0\u10D0\u10D4\u10E0\u10D7\u10D0 \u10D7\u10D0\u10DC\u10D0 \u10DB\u10E0\u10DD\u10DB\u10D0\u10E1\u10D0; \u10DB\u10DD\u10DB\u10EA\u10DC\u10D4\u10E1 \u10E4\u10E0\u10D7\u10D4\u10DC\u10D8 \u10D3\u10D0 \u10D0\u10E6\u10D5\u10E4\u10E0\u10D8\u10DC\u10D3\u10D4, \u10DB\u10D8\u10D5\u10F0\u10EE\u10D5\u10D3\u10D4 \u10DB\u10D0\u10E1 \u10E9\u10D4\u10DB\u10E1\u10D0 \u10DC\u10D3\u10DD\u10DB\u10D0\u10E1\u10D0, \u10D3\u10E6\u10D8\u10E1\u10D8\u10D7 \u10D3\u10D0 \u10E6\u10D0\u10DB\u10D8\u10D7 \u10D5\u10F0\u10EE\u10D4\u10D3\u10D5\u10D8\u10D3\u10D4 \u10DB\u10D6\u10D8\u10E1\u10D0 \u10D4\u10DA\u10D5\u10D0\u10D7\u10D0 \u10D9\u10E0\u10D7\u10DD\u10DB\u10D0\u10D0\u10E1\u10D0\u10E8\u10D4\u10DB\u10D5\u10D4\u10D3\u10E0\u10D4,\u10E8\u10D4\u10DB\u10D5\u10D4\u10D3\u10E0\u10D4,",
+ "\u03A4\u03B7 \u03B3\u03BB\u03CE\u03C3\u03C3\u03B1 \u03BC\u03BF\u03C5 \u03AD\u03B4\u03C9\u03C3\u03B1\u03BD \u03B5\u03BB\u03BB\u03B7\u03BD\u03B9\u03BA\u03AE",
null,
};
Console.WriteLine($"WaitForCompletion started on thread {Thread.CurrentThread.ManagedThreadId}");
await comp.Completion;
Console.WriteLine($"WaitForCompletion completed on thread {Thread.CurrentThread.ManagedThreadId}");
- UpdateProgress("✌︎");
+ UpdateProgress("\u270C\uFE0E");
}
[JSExport]
private readonly Action<string> _updateProgress;
private int _counter = 0;
- private readonly IReadOnlyList<string> _animations = new string[] { "⚀", "⚁", "⚂", "⚃", "⚄", "⚅" };
+ private readonly IReadOnlyList<string> _animations = new string[] { "\u2680", "\u2681", "\u2682", "\u2683", "\u2684", "\u2685" };
public void Step(string suffix = "")
{
await CheckObject(locals, "c", "DebuggerTests.DebuggerDisplayMethodTest", description: "First Int:32 Second Int:43");
await CheckObject(locals, "myList", "System.Collections.Generic.List<int>", description: "Count = 4");
await CheckObject(locals, "person1", "DebuggerTests.Person", description: "FirstName: Anton, SurName: Mueller, Age: 44");
- await CheckObject(locals, "person2", "DebuggerTests.Person", description: "FirstName: Lisa, SurName: Müller, Age: 41");
+ await CheckObject(locals, "person2", "DebuggerTests.Person", description: "FirstName: Lisa, SurName: M\u00FCller, Age: 41");
}
[ConditionalFact(nameof(RunningOnChrome))]
[Theory]
[InlineData("en-US", "dddd, MMMM d, yyyy h:mm:ss tt", "dddd, MMMM d, yyyy", "h:mm:ss tt", "M/d/yyyy", "h:mm tt")]
- [InlineData("ja-JP", "yyyy年M月d日dddd H:mm:ss", "yyyy年M月d日dddd", "H:mm:ss", "yyyy/MM/dd", "H:mm")]
+ [InlineData("ja-JP", "yyyy\u5E74M\u6708d\u65E5dddd H:mm:ss", "yyyy\u5E74M\u6708d\u65E5dddd", "H:mm:ss", "yyyy/MM/dd", "H:mm")]
[InlineData("es-ES", "dddd, d 'de' MMMM 'de' yyyy H:mm:ss", "dddd, d 'de' MMMM 'de' yyyy", "H:mm:ss", "d/M/yyyy", "H:mm")]
[InlineData("de-DE", "dddd, d. MMMM yyyy HH:mm:ss", "dddd, d. MMMM yyyy", "HH:mm:ss", "dd.MM.yyyy", "HH:mm")]
public async Task CheckDateTimeLocale(string locale, string fdtp, string ldp, string ltp, string sdp, string stp)
("this.CallMethodWithParmBool(false)", TString("FALSE")),
("this.CallMethodWithParmString(\"concat\")", TString("str_const_concat")),
("this.CallMethodWithParmString(\"\\\"\\\"\")", TString("str_const_\"\"")),
- ("this.CallMethodWithParmString(\"🛶\")", TString("str_const_🛶")),
- ("this.CallMethodWithParmString(\"\\uD83D\\uDEF6\")", TString("str_const_🛶")),
- ("this.CallMethodWithParmString(\"🚀\")", TString("str_const_🚀")),
- ("this.CallMethodWithParmString_λ(\"🚀\")", TString("λ_🚀")),
+ ("this.CallMethodWithParmString(\"\uD83D\uDEF6\")", TString("str_const_\uD83D\uDEF6")),
+ ("this.CallMethodWithParmString(\"\\uD83D\\uDEF6\")", TString("str_const_\uD83D\uDEF6")),
+ ("this.CallMethodWithParmString(\"\uD83D\uDE80\")", TString("str_const_\uD83D\uDE80")),
+ ("this.CallMethodWithParmString_\u03BB(\"\uD83D\uDE80\")", TString("\u03BB_\uD83D\uDE80")),
("this.CallMethodWithParm(10) + this.a", TNumber(12)),
("this.CallMethodWithObj(null)", TNumber(-1)),
("this.CallMethodWithChar('a')", TString("str_const_a")));
("test.GetChar()", TChar('T')),
("test.GetCharNullable()", TChar('T')),
- ("test.GetUnicodeChar()", TChar('ą')),
+ ("test.GetUnicodeChar()", TChar('\u0105')),
("test.GetString()", TString("1.23")),
- ("test.GetUnicodeString()", TString("żółć")),
+ ("test.GetUnicodeString()", TString("\u017C\u00F3\u0142\u0107")),
("test.GetString(null)", TString(null)),
("test.GetStringNullable()", TString("1.23")),
[ConditionalTheory(nameof(RunningOnChrome))]
[InlineData("ApplyUpdateReferencedAssembly")]
- [InlineData("ApplyUpdateReferencedAssemblyChineseCharInPathㄨ")]
+ [InlineData("ApplyUpdateReferencedAssemblyChineseCharInPath\u3128")]
public async Task DebugHotReloadMethodAddBreakpoint(string assembly_name)
{
int line = 30;
[ConditionalTheory(nameof(RunningOnChrome))]
[InlineData("ApplyUpdateReferencedAssembly")]
- [InlineData("ApplyUpdateReferencedAssemblyChineseCharInPathㄨ")]
+ [InlineData("ApplyUpdateReferencedAssemblyChineseCharInPath\u3128")]
public async Task DebugHotReloadMethodAddBreakpointUsingSDB(string assembly_name)
{
string asm_file = Path.Combine(DebuggerTestAppPath, $"{assembly_name}.dll");
"window.setTimeout(function() { invoke_static_method ('[debugger-test] Math:PrimitiveTypesTest'); }, 1);",
test_fn: async (locals) =>
{
- await CheckSymbol(locals, "c0", '€');
+ await CheckSymbol(locals, "c0", '\u20AC');
await CheckSymbol(locals, "c1", 'A');
await Task.CompletedTask;
}
[ConditionalTheory(nameof(RunningOnChrome))]
[InlineData("lazy-debugger-test")]
- [InlineData("lazy-debugger-test-chinese-char-in-path-ㄨ")]
+ [InlineData("lazy-debugger-test-chinese-char-in-path-\u3128")]
public async Task DebugLazyLoadedAssemblyWithPdb(string assembly_name)
{
Task<JObject> bpResolved = WaitForBreakpointResolvedEvent();
"dotnet://debugger-test-special-char-in-path.dll/test#.cs")]
[InlineData(
"DebuggerTests.CheckSNonAsciiCharactersInPath",
- "dotnet://debugger-test-special-char-in-path.dll/non-ascii-test-ął.cs")]
+ "dotnet://debugger-test-special-char-in-path.dll/non-ascii-test-\u0105\u0142.cs")]
public async Task SetBreakpointInProjectWithSpecialCharactersInPath(
string classWithNamespace, string expectedFileLocation)
{
[ConditionalFact(nameof(RunningOnChrome))]
public async Task SetBreakpointInProjectWithChineseCharactereInPath()
{
- var bp = await SetBreakpointInMethod("debugger-test-chinese-char-in-path-ㄨ.dll", "DebuggerTests.CheckChineseCharacterInPath", "Evaluate", 1);
+ var bp = await SetBreakpointInMethod("debugger-test-chinese-char-in-path-\u3128.dll", "DebuggerTests.CheckChineseCharacterInPath", "Evaluate", 1);
await EvaluateAndCheck(
- $"window.setTimeout(function() {{ invoke_static_method ('[debugger-test-chinese-char-in-path-ㄨ] DebuggerTests.CheckChineseCharacterInPath:Evaluate'); }}, 1);",
- "dotnet://debugger-test-chinese-char-in-path-ㄨ.dll/test.cs",
+ $"window.setTimeout(function() {{ invoke_static_method ('[debugger-test-chinese-char-in-path-\u3128] DebuggerTests.CheckChineseCharacterInPath:Evaluate'); }}, 1);",
+ "dotnet://debugger-test-chinese-char-in-path-\u3128.dll/test.cs",
bp.Value["locations"][0]["lineNumber"].Value<int>(),
bp.Value["locations"][0]["columnNumber"].Value<int>(),
$"DebuggerTests.CheckChineseCharacterInPath.Evaluate");
openWith.Add("bmp", "paint");
openWith.Add("dib", "paint");
var person1 = new Person { FirstName = "Anton", SurName="Mueller", Age = 44};
- var person2 = new Person { FirstName = "Lisa", SurName="Müller", Age = 41};
+ var person2 = new Person { FirstName = "Lisa", SurName="M\u00FCller", Age = 41};
Console.WriteLine("break here");
return str + parm;
}
- public string CallMethodWithParmString_λ(string parm)
+ public string CallMethodWithParmString_\u03BB(string parm)
{
- return "λ_" + parm;
+ return "\u03BB_" + parm;
}
public string CallMethodWithParmBool(bool parm)
public bool GetBool(bool param = true) => param;
public char GetChar(char param = 'T') => param;
- public char GetUnicodeChar(char param = 'ą') => param;
+ public char GetUnicodeChar(char param = '\u0105') => param;
public byte GetByte(byte param = 1) => param;
public sbyte GetSByte(sbyte param = 1) => param;
public short GetInt16(short param = 1) => param;
public float GetSingle(float param = 1.23f) => param;
public double GetDouble(double param = 1.23) => param;
public string GetString(string param = "1.23") => param;
- public string GetUnicodeString(string param = "żółć") => param;
+ public string GetUnicodeString(string param = "\u017C\u00F3\u0142\u0107") => param;
#nullable enable
public bool? GetBoolNullable(bool? param = true) => param;
public static void PrimitiveTypesTest()
{
- char c0 = '€';
+ char c0 = '\u20AC';
char c1 = 'A';
// TODO: other types!
// just trying to ensure vars don't get optimized out
var echoStatus = new EchoStatus
{
Code = 2,
- Message = "\t\ntest with whitespace\r\nand Unicode BMP ☺ and non-BMP 😈\t\n"
+ Message = "\t\ntest with whitespace\r\nand Unicode BMP \u263A and non-BMP \uD83D\uDE08\t\n"
};
try
Tuple.Create("", "def"),
Tuple.Create("abc", ""),
Tuple.Create("abc", "def"),
- Tuple.Create("", "结合"),
- Tuple.Create("结合", ""),
- Tuple.Create("a", "结合"),
- Tuple.Create("结合", "a"),
- Tuple.Create("结合", "结合"),
+ Tuple.Create("", "\u7ED3\u5408"),
+ Tuple.Create("\u7ED3\u5408", ""),
+ Tuple.Create("a", "\u7ED3\u5408"),
+ Tuple.Create("\u7ED3\u5408", "a"),
+ Tuple.Create("\u7ED3\u5408", "\u7ED3\u5408"),
// String marshalling is optimized where strings shorter than MAX_PATH are
// allocated on the stack. Longer strings have memory allocated for them.
"a",
"abc",
"reversible string",
- "Unicode 相反 Unicode",
+ "Unicode \u76F8\u53CD Unicode",
// Long string optimization validation
"123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901"
// We use a the "green check mark" character so that we use both bytes and
// have a value that can't be accidentally round-tripped.
- char c = '✅';
+ char c = '\u2705';
Assert.True(DisabledRuntimeMarshallingNative.CheckStructWithWCharAndShort(new StructWithWCharAndShortWithMarshalAs(s, c), s, c));
}
// We use a the "green check mark" character so that we use both bytes and
// have a value that can't be accidentally round-tripped.
- char c = '✅';
+ char c = '\u2705';
Assert.True(DisabledRuntimeMarshallingNative.CheckStructWithWCharAndShort(new StructWithWCharAndShort(s, c), s, c));
Assert.False(DisabledRuntimeMarshallingNative.CheckStructWithShortAndBoolWithVariantBool_FailureExpected(new StructWithShortAndBool(s, b), s, b));
short s = 42;
// We use a the "green check mark" character so that we use both bytes and
// have a value that can't be accidentally round-tripped.
- char c = '✅';
+ char c = '\u2705';
Assert.True(DisabledRuntimeMarshallingNative.CheckStructWithWCharAndShort(new StructWithShortAndGeneric<char>(s, c), s, c));
}
short s = 42;
// We use a the "green check mark" character so that we use both bytes and
// have a value that can't be accidentally round-tripped.
- char c = '✅';
+ char c = '\u2705';
Assert.True(DisabledRuntimeMarshallingNative.CheckStructWithWCharAndShort(new StructWithShortAndGeneric<short>(s, (short)c), s, (short)c));
}
short s = 42;
// We use a the "green check mark" character so that we use both bytes and
// have a value that can't be accidentally round-tripped.
- char c = '✅';
+ char c = '\u2705';
Assert.False(DisabledRuntimeMarshallingNative.CheckStructWithWCharAndShort(new StructWithWCharAndShort(s, c), s, c));
}
short s = 41;
// We use a the "green check mark" character so that we use both bytes and
// have a value that can't be accidentally round-tripped.
- char c = '✅';
+ char c = '\u2705';
Assert.False(DisabledRuntimeMarshallingNative.CheckStructWithWCharAndShort(new StructWithWCharAndShortWithMarshalAs(s, c), s, c));
}
public static void StructWithNonBlittableGenericInstantiation_Fails()
{
short s = 41;
- char c = '✅';
+ char c = '\u2705';
Assert.Throws<MarshalDirectiveException>(() => DisabledRuntimeMarshallingNative.CheckStructWithWCharAndShort(new StructWithShortAndGeneric<char>(s, c), s, c));
}
short s = 42;
// We use a the "green check mark" character so that we use both bytes and
// have a value that can't be accidentally round-tripped.
- char c = '✅';
+ char c = '\u2705';
Assert.True(DisabledRuntimeMarshallingNative.CheckStructWithWCharAndShort(new StructWithShortAndGeneric<short>(s, (short)c), s, (short)c));
}
private const string RelativePath1Unix = @"./RelativeNative/../libDllImportPath_Relative";
private const string RelativePath3Unix = @"../DllImportPathTest/libDllImportPath_Relative";
- private const string UnicodeFileName = "DllImportPath_Unicode✔";
+ private const string UnicodeFileName = "DllImportPath_Unicode\u2714";
[DllImport(@"DllImportPath_Local", EntryPoint = "GetZero")]
private static extern int GetZero_Local1();
public static class TestData
{
public const char InvalidChar = (char)0x2216;
- public const char UnmappableChar = '火';
+ public const char UnmappableChar = '\u706B';
public const char ValidChar = 'c';
public static readonly string InvalidString = new string(new char[]
(char)0x0589,
(char)0x2236
});
- public static readonly string UnmappableString = new string(new char[] { '乀', 'Ω', '火' });
+ public static readonly string UnmappableString = new string(new char[] { '\u4E40', '\u2126', '\u706B' });
public static readonly string ValidString = "This is the initial test string.";
public static readonly StringBuilder InvalidStringBuilder = new StringBuilder(InvalidString);
{
private static readonly string InitialString = "Hello World";
private static readonly string LongString = "0123456789abcdefghi";
- private static readonly string LongUnicodeString = "👨👨👧👧🐱👤";
+ private static readonly string LongUnicodeString = "\uD83D\uDC68\u200D\uD83D\uDC68\u200D\uD83D\uDC67\u200D\uD83D\uDC67\uD83D\uDC31\u200D\uD83D\uDC64";
public static int Main()
{
//test strings
public static string[] utf8Strings = {
"Managed",
- "Sîne klâwen durh die wolken sint geslagen" ,
- "काचं शक्नोम्यत्तुम् । नोपहिनस्ति माम्",
- "我能吞下玻璃而不伤身体",
- "ღმერთსი შემვედრე,შემვედრე, ნუთუ კვლა დამხსნას შემვედრე,სოფლისა შემვედრე, შემვედრე,შემვედრე,შემვედრე,შრომასა, ცეცხლს, წყალსა და მიწასა, ჰაერთა თანა მრომასა; მომცნეს ფრთენი და აღვფრინდე, მივჰხვდე მას ჩემსა ნდომასა, დღისით და ღამით ვჰხედვიდე მზისა ელვათა კრთომაასაშემვედრე,შემვედრე,",
- "Τη γλώσσα μου έδωσαν ελληνική",
+ "S\u00EEne kl\u00E2wen durh die wolken sint geslagen" ,
+ "\u0915\u093E\u091A\u0902 \u0936\u0915\u094D\u0928\u094B\u092E\u094D\u092F\u0924\u094D\u0924\u0941\u092E\u094D \u0964 \u0928\u094B\u092A\u0939\u093F\u0928\u0938\u094D\u0924\u093F \u092E\u093E\u092E\u094D",
+ "\u6211\u80FD\u541E\u4E0B\u73BB\u7483\u800C\u4E0D\u4F24\u8EAB\u4F53",
+ "\u10E6\u10DB\u10D4\u10E0\u10D7\u10E1\u10D8 \u10E8\u10D4\u10DB\u10D5\u10D4\u10D3\u10E0\u10D4,\u10E8\u10D4\u10DB\u10D5\u10D4\u10D3\u10E0\u10D4, \u10DC\u10E3\u10D7\u10E3 \u10D9\u10D5\u10DA\u10D0 \u10D3\u10D0\u10DB\u10EE\u10E1\u10DC\u10D0\u10E1 \u10E8\u10D4\u10DB\u10D5\u10D4\u10D3\u10E0\u10D4,\u10E1\u10DD\u10E4\u10DA\u10D8\u10E1\u10D0 \u10E8\u10D4\u10DB\u10D5\u10D4\u10D3\u10E0\u10D4, \u10E8\u10D4\u10DB\u10D5\u10D4\u10D3\u10E0\u10D4,\u10E8\u10D4\u10DB\u10D5\u10D4\u10D3\u10E0\u10D4,\u10E8\u10D4\u10DB\u10D5\u10D4\u10D3\u10E0\u10D4,\u10E8\u10E0\u10DD\u10DB\u10D0\u10E1\u10D0, \u10EA\u10D4\u10EA\u10EE\u10DA\u10E1, \u10EC\u10E7\u10D0\u10DA\u10E1\u10D0 \u10D3\u10D0 \u10DB\u10D8\u10EC\u10D0\u10E1\u10D0, \u10F0\u10D0\u10D4\u10E0\u10D7\u10D0 \u10D7\u10D0\u10DC\u10D0 \u10DB\u10E0\u10DD\u10DB\u10D0\u10E1\u10D0; \u10DB\u10DD\u10DB\u10EA\u10DC\u10D4\u10E1 \u10E4\u10E0\u10D7\u10D4\u10DC\u10D8 \u10D3\u10D0 \u10D0\u10E6\u10D5\u10E4\u10E0\u10D8\u10DC\u10D3\u10D4, \u10DB\u10D8\u10D5\u10F0\u10EE\u10D5\u10D3\u10D4 \u10DB\u10D0\u10E1 \u10E9\u10D4\u10DB\u10E1\u10D0 \u10DC\u10D3\u10DD\u10DB\u10D0\u10E1\u10D0, \u10D3\u10E6\u10D8\u10E1\u10D8\u10D7 \u10D3\u10D0 \u10E6\u10D0\u10DB\u10D8\u10D7 \u10D5\u10F0\u10EE\u10D4\u10D3\u10D5\u10D8\u10D3\u10D4 \u10DB\u10D6\u10D8\u10E1\u10D0 \u10D4\u10DA\u10D5\u10D0\u10D7\u10D0 \u10D9\u10E0\u10D7\u10DD\u10DB\u10D0\u10D0\u10E1\u10D0\u10E8\u10D4\u10DB\u10D5\u10D4\u10D3\u10E0\u10D4,\u10E8\u10D4\u10DB\u10D5\u10D4\u10D3\u10E0\u10D4,",
+ "\u03A4\u03B7 \u03B3\u03BB\u03CE\u03C3\u03C3\u03B1 \u03BC\u03BF\u03C5 \u03AD\u03B4\u03C9\u03C3\u03B1\u03BD \u03B5\u03BB\u03BB\u03B7\u03BD\u03B9\u03BA\u03AE",
null,
};
// The validation logic defined here for Bmi2.ParallelBitDeposit and Bmi2.ParallelBitExtract is
-// based on the 'Operation' pseudo-code defined for the pdep and pext instruction in the 'Intel®
+// based on the 'Operation' pseudo-code defined for the pdep and pext instruction in the 'Intel\u00AE
// 64 and IA-32 Architectures Software Developer’s Manual; Volume 2 (2A, 2B, 2C & 2D): Instruction
// Set Reference, A-Z'
// The validation logic defined here for Bmi2.ParallelBitDeposit and Bmi2.ParallelBitExtract is
-// based on the 'Operation' pseudo-code defined for the pdep and pext instruction in the 'Intel®
+// based on the 'Operation' pseudo-code defined for the pdep and pext instruction in the 'Intel\u00AE
// 64 and IA-32 Architectures Software Developer’s Manual; Volume 2 (2A, 2B, 2C & 2D): Instruction
// Set Reference, A-Z'
// The validation logic defined here for Bmi2.ParallelBitDeposit and Bmi2.ParallelBitExtract is
-// based on the 'Operation' pseudo-code defined for the pdep and pext instruction in the 'Intel®
+// based on the 'Operation' pseudo-code defined for the pdep and pext instruction in the 'Intel\u00AE
// 64 and IA-32 Architectures Software Developer’s Manual; Volume 2 (2A, 2B, 2C & 2D): Instruction
// Set Reference, A-Z'
// The validation logic defined here for Bmi2.ParallelBitDeposit and Bmi2.ParallelBitExtract is
-// based on the 'Operation' pseudo-code defined for the pdep and pext instruction in the 'Intel®
+// based on the 'Operation' pseudo-code defined for the pdep and pext instruction in the 'Intel\u00AE
// 64 and IA-32 Architectures Software Developer’s Manual; Volume 2 (2A, 2B, 2C & 2D): Instruction
// Set Reference, A-Z'
// Method: Simulate a bouncing ball based on the laws of physics.
// The general principles:
-// The velocity of a falling ball is : (½) m v^2 = m g d è v = sqrt(2 * g * d)
+// The velocity of a falling ball is : (\u00BD) m v^2 = m g d \u00E8 v = sqrt(2 * g * d)
// The non-ellastic collision will shoot the ball in
// the opposite direction at : v2 = e v = e * sqrt(2 * g * d)
// Where e is the coeficient of restitution
}
}
- string[] strings = { "", "0", "00", "1", "11", "111", "привет", "Hello" };
+ string[] strings = { "", "0", "00", "1", "11", "111", "\u043F\u0440\u0438\u0432\u0435\u0442", "Hello" };
foreach (var str1 in strings)
{
foreach (var str2 in strings)
[MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_0(string s) => ValidateEquals(s == "", s, "");
[MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_1(string s) => ValidateEquals(s == "3", s, "3");
[MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_2(string s) => ValidateEquals(s == "\0", s, "\0");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_3(string s) => ValidateEquals(s == "ж", s, "ж");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_3(string s) => ValidateEquals(s == "\u0436", s, "\u0436");
[MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_4(string s) => ValidateEquals(s == "1", s, "1");
[MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_5(string s) => ValidateEquals(s == "33", s, "33");
[MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_6(string s) => ValidateEquals(s == "31", s, "31");
[MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_8(string s) => ValidateEquals(s == "12", s, "12");
[MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_9(string s) => ValidateEquals(s == "1\0", s, "1\0");
[MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_10(string s) => ValidateEquals(s == "b12", s, "b12");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_11(string s) => ValidateEquals(s == "ж23", s, "ж23");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_11(string s) => ValidateEquals(s == "\u043623", s, "\u043623");
[MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_12(string s) => ValidateEquals(s == "2a2", s, "2a2");
[MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_13(string s) => ValidateEquals(s == "222", s, "222");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_14(string s) => ValidateEquals(s == "0ь3", s, "0ь3");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_15(string s) => ValidateEquals(s == "bж31", s, "bж31");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_16(string s) => ValidateEquals(s == "ьЙbЙ", s, "ьЙbЙ");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_14(string s) => ValidateEquals(s == "0\u044C3", s, "0\u044C3");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_15(string s) => ValidateEquals(s == "b\u043631", s, "b\u043631");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_16(string s) => ValidateEquals(s == "\u044C\u0419b\u0419", s, "\u044C\u0419b\u0419");
[MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_17(string s) => ValidateEquals(s == "b033", s, "b033");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_18(string s) => ValidateEquals(s == "311ь", s, "311ь");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_19(string s) => ValidateEquals(s == "жЙ12", s, "жЙ12");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_18(string s) => ValidateEquals(s == "311\u044C", s, "311\u044C");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_19(string s) => ValidateEquals(s == "\u0436\u041912", s, "\u0436\u041912");
[MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_20(string s) => ValidateEquals(s == "2011b", s, "2011b");
[MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_21(string s) => ValidateEquals(s == "222b2", s, "222b2");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_22(string s) => ValidateEquals(s == "aЙ213", s, "aЙ213");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_22(string s) => ValidateEquals(s == "a\u0419213", s, "a\u0419213");
[MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_23(string s) => ValidateEquals(s == "1a131", s, "1a131");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_24(string s) => ValidateEquals(s == "3232Й", s, "3232Й");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_25(string s) => ValidateEquals(s == "3b0ьжь", s, "3b0ьжь");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_26(string s) => ValidateEquals(s == "213b2Й", s, "213b2Й");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_24(string s) => ValidateEquals(s == "3232\u0419", s, "3232\u0419");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_25(string s) => ValidateEquals(s == "3b0\u044C\u0436\u044C", s, "3b0\u044C\u0436\u044C");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_26(string s) => ValidateEquals(s == "213b2\u0419", s, "213b2\u0419");
[MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_27(string s) => ValidateEquals(s == "b31210", s, "b31210");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_28(string s) => ValidateEquals(s == "1ж0021", s, "1ж0021");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_29(string s) => ValidateEquals(s == "3ь3112", s, "3ь3112");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_28(string s) => ValidateEquals(s == "1\u04360021", s, "1\u04360021");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_29(string s) => ValidateEquals(s == "3\u044C3112", s, "3\u044C3112");
[MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_30(string s) => ValidateEquals(s == "122b231", s, "122b231");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_31(string s) => ValidateEquals(s == "03ж32ж3", s, "03ж32ж3");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_32(string s) => ValidateEquals(s == "bb31ж2Й", s, "bb31ж2Й");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_33(string s) => ValidateEquals(s == "023bьжЙ", s, "023bьжЙ");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_31(string s) => ValidateEquals(s == "03\u043632\u04363", s, "03\u043632\u04363");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_32(string s) => ValidateEquals(s == "bb31\u04362\u0419", s, "bb31\u04362\u0419");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_33(string s) => ValidateEquals(s == "023b\u044C\u0436\u0419", s, "023b\u044C\u0436\u0419");
[MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_34(string s) => ValidateEquals(s == "\0232a12", s, "\0232a12");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_35(string s) => ValidateEquals(s == "ж13ь11Йь", s, "ж13ь11Йь");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_36(string s) => ValidateEquals(s == "11ьbb32ь", s, "11ьbb32ь");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_37(string s) => ValidateEquals(s == "222Йж3ж3", s, "222Йж3ж3");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_38(string s) => ValidateEquals(s == "ж303aЙ12", s, "ж303aЙ12");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_39(string s) => ValidateEquals(s == "ьb22322b", s, "ьb22322b");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_40(string s) => ValidateEquals(s == "a22b10b1Й", s, "a22b10b1Й");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_41(string s) => ValidateEquals(s == "3ba2221ь3", s, "3ba2221ь3");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_42(string s) => ValidateEquals(s == "жa1Й0b1Й1", s, "жa1Й0b1Й1");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_43(string s) => ValidateEquals(s == "a20Йжж1ьь", s, "a20Йжж1ьь");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_44(string s) => ValidateEquals(s == "ьaж32132ь", s, "ьaж32132ь");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_45(string s) => ValidateEquals(s == "11111Й3Й12", s, "11111Й3Й12");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_46(string s) => ValidateEquals(s == "11Й\02Йb3жж", s, "11Й\02Йb3жж");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_47(string s) => ValidateEquals(s == "21bжжж0103", s, "21bжжж0103");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_48(string s) => ValidateEquals(s == "333332aЙ11", s, "333332aЙ11");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_49(string s) => ValidateEquals(s == "Й123112313", s, "Й123112313");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_50(string s) => ValidateEquals(s == "12ЙьЙaЙ11ьb", s, "12ЙьЙaЙ11ьb");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_51(string s) => ValidateEquals(s == "жж22221Й3Й2", s, "жж22221Й3Й2");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_52(string s) => ValidateEquals(s == "ьЙ1bbж3202ж", s, "ьЙ1bbж3202ж");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_53(string s) => ValidateEquals(s == "1bbЙ2Й33Й2ж", s, "1bbЙ2Й33Й2ж");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_54(string s) => ValidateEquals(s == "2013133ь1bж", s, "2013133ь1bж");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_55(string s) => ValidateEquals(s == "23a2\02жa2a13", s, "23a2\02жa2a13");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_56(string s) => ValidateEquals(s == "23Й210Й3a3ж1", s, "23Й210Й3a3ж1");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_57(string s) => ValidateEquals(s == "32Й2133bb2Й3", s, "32Й2133bb2Й3");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_58(string s) => ValidateEquals(s == "Й3bb1ь3bbьb3", s, "Й3bb1ь3bbьb3");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_59(string s) => ValidateEquals(s == "a0Йbabж2Й133", s, "a0Йbabж2Й133");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_60(string s) => ValidateEquals(s == "320жa22a11ж1b", s, "320жa22a11ж1b");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_61(string s) => ValidateEquals(s == "ь321b3ьЙЙ13Й2", s, "ь321b3ьЙЙ13Й2");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_62(string s) => ValidateEquals(s == "a3ь1ж2a\022a1a", s, "a3ь1ж2a\022a1a");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_63(string s) => ValidateEquals(s == "3Йb30b33231bь", s, "3Йb30b33231bь");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_64(string s) => ValidateEquals(s == "2210121ж13231", s, "2210121ж13231");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_65(string s) => ValidateEquals(s == "013311aa3203Й1", s, "013311aa3203Й1");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_66(string s) => ValidateEquals(s == "12ЙЙ1Й2aЙ2ьbЙa", s, "12ЙЙ1Й2aЙ2ьbЙa");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_67(string s) => ValidateEquals(s == "2b1Й11130221bь", s, "2b1Й11130221bь");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_68(string s) => ValidateEquals(s == "230110Й0b3112ж", s, "230110Й0b3112ж");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_69(string s) => ValidateEquals(s == "a213ьab121b332", s, "a213ьab121b332");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_70(string s) => ValidateEquals(s == "111a01ж3121b123", s, "111a01ж3121b123");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_71(string s) => ValidateEquals(s == "13a322Й2Й3bжb0Й", s, "13a322Й2Й3bжb0Й");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_72(string s) => ValidateEquals(s == "\021232b1Йaa1032", s, "\021232b1Йaa1032");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_73(string s) => ValidateEquals(s == "жЙ112ьb12Йь3b2ж", s, "жЙ112ьb12Йь3b2ж");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_74(string s) => ValidateEquals(s == "2bьь331bb\023122", s, "2bьь331bb\023122");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_75(string s) => ValidateEquals(s == "aж22Й2203b023bь3", s, "aж22Й2203b023bь3");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_76(string s) => ValidateEquals(s == "aЙ033ж3a220ь3331", s, "aЙ033ж3a220ь3331");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_77(string s) => ValidateEquals(s == "20Йжa1b1313жЙb2a", s, "20Йжa1b1313жЙb2a");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_78(string s) => ValidateEquals(s == "131Й1\022ж2322123", s, "131Й1\022ж2322123");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_79(string s) => ValidateEquals(s == "23323b21ь11bЙ321", s, "23323b21ь11bЙ321");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_80(string s) => ValidateEquals(s == "302aьжa3213жaЙ3Йж", s, "302aьжa3213жaЙ3Йж");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_81(string s) => ValidateEquals(s == "ж13b00210b1212102", s, "ж13b00210b1212102");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_82(string s) => ValidateEquals(s == "20320Й3Й3ьж3Й2122", s, "20320Й3Й3ьж3Й2122");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_83(string s) => ValidateEquals(s == "0bb23a30baЙb2333ь", s, "0bb23a30baЙb2333ь");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_84(string s) => ValidateEquals(s == "22122ь130230103a2", s, "22122ь130230103a2");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_85(string s) => ValidateEquals(s == "ььba20ж1жьЙьbЙ31bж", s, "ььba20ж1жьЙьbЙ31bж");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_86(string s) => ValidateEquals(s == "bb1ь1033bж3011bж10", s, "bb1ь1033bж3011bж10");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_87(string s) => ValidateEquals(s == "1ь320a3a22b3333b13", s, "1ь320a3a22b3333b13");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_88(string s) => ValidateEquals(s == "0a22aЙжa2222ж23Й13", s, "0a22aЙжa2222ж23Й13");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_89(string s) => ValidateEquals(s == "Й11Й213212ж1233b23", s, "Й11Й213212ж1233b23");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_90(string s) => ValidateEquals(s == "32ь1Й03123ь011332ab", s, "32ь1Й03123ь011332ab");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_91(string s) => ValidateEquals(s == "222ж2311b133b3ж3223", s, "222ж2311b133b3ж3223");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_92(string s) => ValidateEquals(s == "0111ь3002222a3aaaa3", s, "0111ь3002222a3aaaa3");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_93(string s) => ValidateEquals(s == "313Й213aж01a12231a2", s, "313Й213aж01a12231a2");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_94(string s) => ValidateEquals(s == "1ж022ь1323b3b3ж222ь", s, "1ж022ь1323b3b3ж222ь");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_95(string s) => ValidateEquals(s == "ь023a3b213ь033ж13231", s, "ь023a3b213ь033ж13231");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_96(string s) => ValidateEquals(s == "ab2b0bь322300ж2220ж2", s, "ab2b0bь322300ж2220ж2");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_97(string s) => ValidateEquals(s == "1133Й323223ж31002123", s, "1133Й323223ж31002123");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_98(string s) => ValidateEquals(s == "233ж0b3Й023Йьaaж3321", s, "233ж0b3Й023Йьaaж3321");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_99(string s) => ValidateEquals(s == "3Й11b313323230a02Й30", s, "3Й11b313323230a02Й30");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_100(string s) => ValidateEquals(s == "1ж2Йж0131a2ж2aЙЙ3ьb11", s, "1ж2Йж0131a2ж2aЙЙ3ьb11");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_101(string s) => ValidateEquals(s == "Й13303ba3ьж31a1102222", s, "Й13303ba3ьж31a1102222");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_102(string s) => ValidateEquals(s == "32331221ь3ьb103212132", s, "32331221ь3ьb103212132");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_103(string s) => ValidateEquals(s == "133Й0332210231331100Й", s, "133Й0332210231331100Й");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_104(string s) => ValidateEquals(s == "22221322Й1133bb0Й3222", s, "22221322Й1133bb0Й3222");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_105(string s) => ValidateEquals(s == "12b011ж3a1ж3ЙЙa12Й0ь3ь", s, "12b011ж3a1ж3ЙЙa12Й0ь3ь");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_106(string s) => ValidateEquals(s == "0333ь12113ь11331ж323Йж", s, "0333ь12113ь11331ж323Йж");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_107(string s) => ValidateEquals(s == "0Й13a310ь12\02ь\02320331", s, "0Й13a310ь12\02ь\02320331");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_108(string s) => ValidateEquals(s == "022b2ьж0302b33Й21ж1112", s, "022b2ьж0302b33Й21ж1112");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_109(string s) => ValidateEquals(s == "3322ж2133133b3032Йaa12", s, "3322ж2133133b3032Йaa12");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_110(string s) => ValidateEquals(s == "Й132Йaьb33a3Й33Йb21a2b2", s, "Й132Йaьb33a3Й33Йb21a2b2");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_111(string s) => ValidateEquals(s == "31102113Й11жb31bЙ12b133", s, "31102113Й11жb31bЙ12b133");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_112(string s) => ValidateEquals(s == "ЙьЙЙ0Й03a\023ь3311ьЙ1323", s, "ЙьЙЙ0Й03a\023ь3311ьЙ1323");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_113(string s) => ValidateEquals(s == "212323жa23203bb00жa12ж3", s, "212323жa23203bb00жa12ж3");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_114(string s) => ValidateEquals(s == "жЙ31130ж32322313010aa13", s, "жЙ31130ж32322313010aa13");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_115(string s) => ValidateEquals(s == "123aж2221\022ж22Й021bЙЙ0Й", s, "123aж2221\022ж22Й021bЙЙ0Й");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_116(string s) => ValidateEquals(s == "211131ж2213303b1b0231a11", s, "211131ж2213303b1b0231a11");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_117(string s) => ValidateEquals(s == "ь1aЙжь0110Й2b220жж3ьж3ж1", s, "ь1aЙжь0110Й2b220жж3ьж3ж1");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_118(string s) => ValidateEquals(s == "3жab2221133331311\023ЙЙ3ж", s, "3жab2221133331311\023ЙЙ3ж");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_119(string s) => ValidateEquals(s == "21Й20\02ьь333ьb332223Йж1Й", s, "21Й20\02ьь333ьb332223Йж1Й");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_120(string s) => ValidateEquals(s == "1Й2120a01110Й1121003a3b33", s, "1Й2120a01110Й1121003a3b33");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_121(string s) => ValidateEquals(s == "3021a1Й1aa1111b22Й112Й201", s, "3021a1Й1aa1111b22Й112Й201");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_122(string s) => ValidateEquals(s == "2b21ьaьb\023Й33301Й3123Йж1", s, "2b21ьaьb\023Й33301Й3123Йж1");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_123(string s) => ValidateEquals(s == "2ж1baЙЙ1a\021ж23323жbж331ж", s, "2ж1baЙЙ1a\021ж23323жbж331ж");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_124(string s) => ValidateEquals(s == "bab12332ж31130Й3230ь1011a", s, "bab12332ж31130Й3230ь1011a");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_125(string s) => ValidateEquals(s == "110aь31ж33ьь33333a2b32ь12ь", s, "110aь31ж33ьь33333a2b32ь12ь");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_126(string s) => ValidateEquals(s == "a2жЙ11ь1bь312a11aьaьb02Йb0", s, "a2жЙ11ь1bь312a11aьaьb02Йb0");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_127(string s) => ValidateEquals(s == "32b2ж12a32a3ж23ж1ьЙbb22213", s, "32b2ж12a32a3ж23ж1ьЙbb22213");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_128(string s) => ValidateEquals(s == "30ж111ь11120жжb10212жbь33Й", s, "30ж111ь11120жжb10212жbь33Й");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_129(string s) => ValidateEquals(s == "33b1311ж1\023bж020Й10b0302ж", s, "33b1311ж1\023bж020Й10b0302ж");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_130(string s) => ValidateEquals(s == "b3122жa12\021123a3130100113ь", s, "b3122жa12\021123a3130100113ь");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_131(string s) => ValidateEquals(s == "302a1ж322\021221\02a1331b2жь1", s, "302a1ж322\021221\02a1331b2жь1");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_132(string s) => ValidateEquals(s == "31201322жж\0221Й\021Йьь32Й11ж", s, "31201322жж\0221Й\021Йьь32Й11ж");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_133(string s) => ValidateEquals(s == "3bжa132a13ba1311ж1Й22ЙbЙa33", s, "3bжa132a13ba1311ж1Й22ЙbЙa33");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_134(string s) => ValidateEquals(s == "b33Й113ЙЙab1b332211222Й32\02", s, "b33Й113ЙЙab1b332211222Й32\02");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_135(string s) => ValidateEquals(s == "0ж333b31b212121b1aж02ж133111", s, "0ж333b31b212121b1aж02ж133111");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_136(string s) => ValidateEquals(s == "0101Й220Й0жЙ3Й2abba0b1223aab", s, "0101Й220Й0жЙ3Й2abba0b1223aab");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_137(string s) => ValidateEquals(s == "2Й330bЙ123ж2ж02ж212ь112111Й1", s, "2Й330bЙ123ж2ж02ж212ь112111Й1");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_138(string s) => ValidateEquals(s == "22a\0212aь3b1303Й3bb2b313Й222", s, "22a\0212aь3b1303Й3bb2b313Й222");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_139(string s) => ValidateEquals(s == "2ьж133332102222\020Йжbb2\022\02", s, "2ьж133332102222\020Йжbb2\022\02");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_140(string s) => ValidateEquals(s == "2\02321b31123231b2ЙЙ122abЙ2131", s, "2\02321b31123231b2ЙЙ122abЙ2131");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_141(string s) => ValidateEquals(s == "1b021ьЙ30a2332ь3Й12231жж1aжь1", s, "1b021ьЙ30a2332ь3Й12231жж1aжь1");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_142(string s) => ValidateEquals(s == "1ж3ьь3ь1ь1ь0ж1Й122132a2ььaЙ3b", s, "1ж3ьь3ь1ь1ь0ж1Й122132a2ььaЙ3b");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_143(string s) => ValidateEquals(s == "21bbb31301ь3жaaж0Й3323b33ь1ь1", s, "21bbb31301ь3жaaж0Й3323b33ь1ь1");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_144(string s) => ValidateEquals(s == "a00Йь11жжaa321ьЙ1Й31жa21ж3223", s, "a00Йь11жжaa321ьЙ1Й31жa21ж3223");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_145(string s) => ValidateEquals(s == "3132b0Йb3110ab\0201Й1ж32222a33ж", s, "3132b0Йb3110ab\0201Й1ж32222a33ж");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_146(string s) => ValidateEquals(s == "32b110bb312ь02Й1b2Й23232Й12ь33", s, "32b110bb312ь02Й1b2Й23232Й12ь33");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_147(string s) => ValidateEquals(s == "ж121bbbЙ2b1ж12222Йь1Йb02013жь1", s, "ж121bbbЙ2b1ж12222Йь1Йb02013жь1");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_148(string s) => ValidateEquals(s == "ь1b00a3310231001b1a1ь33жжb130ь", s, "ь1b00a3310231001b1a1ь33жжb130ь");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_149(string s) => ValidateEquals(s == "ж3b211b121ж23bь12a1Й2Йж12313aж", s, "ж3b211b121ж23bь12a1Й2Йж12313aж");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_150(string s) => ValidateEquals(s == "1a3жb31311322жь33213Й3ь13330жa3", s, "1a3жb31311322жь33213Й3ь13330жa3");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_151(string s) => ValidateEquals(s == "b33Йbж3333233101a33ж3b231221ь11", s, "b33Йbж3333233101a33ж3b231221ь11");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_152(string s) => ValidateEquals(s == "1Й212Й3ж112a31aьжьЙ32ж233a32Й1ж", s, "1Й212Й3ж112a31aьжьЙ32ж233a32Й1ж");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_153(string s) => ValidateEquals(s == "133ь02aьa0Й3Йab3ь1Й3Й2a21121210", s, "133ь02aьa0Й3Йab3ь1Й3Й2a21121210");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_154(string s) => ValidateEquals(s == "1320baж31b3Й2Й1322b113212212331", s, "1320baж31b3Й2Й1322b113212212331");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_155(string s) => ValidateEquals(s == "1Йa332132жb31Й33Й32321ж31b120ж03", s, "1Йa332132жb31Й33Й32321ж31b120ж03");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_156(string s) => ValidateEquals(s == "213321a1b3жь3111жЙ2b2Й3101221ь33", s, "213321a1b3жь3111жЙ2b2Й3101221ь33");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_157(string s) => ValidateEquals(s == "2ж1311a23b2212aЙ21Й11жb3233bb3a1", s, "2ж1311a23b2212aЙ21Й11жb3233bb3a1");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_158(string s) => ValidateEquals(s == "01Й11113ь3Й32a3ьЙЙ3Й32b2ab221310", s, "01Й11113ь3Й32a3ьЙЙ3Й32b2ab221310");
- [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_159(string s) => ValidateEquals(s == "a120213b11211\0223223312ьь1Й3222Й", s, "a120213b11211\0223223312ьь1Й3222Й");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_35(string s) => ValidateEquals(s == "\u043613\u044C11\u0419\u044C", s, "\u043613\u044C11\u0419\u044C");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_36(string s) => ValidateEquals(s == "11\u044Cbb32\u044C", s, "11\u044Cbb32\u044C");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_37(string s) => ValidateEquals(s == "222\u0419\u04363\u04363", s, "222\u0419\u04363\u04363");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_38(string s) => ValidateEquals(s == "\u0436303a\u041912", s, "\u0436303a\u041912");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_39(string s) => ValidateEquals(s == "\u044Cb22322b", s, "\u044Cb22322b");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_40(string s) => ValidateEquals(s == "a22b10b1\u0419", s, "a22b10b1\u0419");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_41(string s) => ValidateEquals(s == "3ba2221\u044C3", s, "3ba2221\u044C3");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_42(string s) => ValidateEquals(s == "\u0436a1\u04190b1\u04191", s, "\u0436a1\u04190b1\u04191");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_43(string s) => ValidateEquals(s == "a20\u0419\u0436\u04361\u044C\u044C", s, "a20\u0419\u0436\u04361\u044C\u044C");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_44(string s) => ValidateEquals(s == "\u044Ca\u043632132\u044C", s, "\u044Ca\u043632132\u044C");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_45(string s) => ValidateEquals(s == "11111\u04193\u041912", s, "11111\u04193\u041912");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_46(string s) => ValidateEquals(s == "11\u0419\02\u0419b3\u0436\u0436", s, "11\u0419\02\u0419b3\u0436\u0436");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_47(string s) => ValidateEquals(s == "21b\u0436\u0436\u04360103", s, "21b\u0436\u0436\u04360103");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_48(string s) => ValidateEquals(s == "333332a\u041911", s, "333332a\u041911");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_49(string s) => ValidateEquals(s == "\u0419123112313", s, "\u0419123112313");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_50(string s) => ValidateEquals(s == "12\u0419\u044C\u0419a\u041911\u044Cb", s, "12\u0419\u044C\u0419a\u041911\u044Cb");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_51(string s) => ValidateEquals(s == "\u0436\u043622221\u04193\u04192", s, "\u0436\u043622221\u04193\u04192");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_52(string s) => ValidateEquals(s == "\u044C\u04191bb\u04363202\u0436", s, "\u044C\u04191bb\u04363202\u0436");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_53(string s) => ValidateEquals(s == "1bb\u04192\u041933\u04192\u0436", s, "1bb\u04192\u041933\u04192\u0436");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_54(string s) => ValidateEquals(s == "2013133\u044C1b\u0436", s, "2013133\u044C1b\u0436");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_55(string s) => ValidateEquals(s == "23a2\02\u0436a2a13", s, "23a2\02\u0436a2a13");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_56(string s) => ValidateEquals(s == "23\u0419210\u04193a3\u04361", s, "23\u0419210\u04193a3\u04361");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_57(string s) => ValidateEquals(s == "32\u04192133bb2\u04193", s, "32\u04192133bb2\u04193");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_58(string s) => ValidateEquals(s == "\u04193bb1\u044C3bb\u044Cb3", s, "\u04193bb1\u044C3bb\u044Cb3");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_59(string s) => ValidateEquals(s == "a0\u0419bab\u04362\u0419133", s, "a0\u0419bab\u04362\u0419133");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_60(string s) => ValidateEquals(s == "320\u0436a22a11\u04361b", s, "320\u0436a22a11\u04361b");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_61(string s) => ValidateEquals(s == "\u044C321b3\u044C\u0419\u041913\u04192", s, "\u044C321b3\u044C\u0419\u041913\u04192");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_62(string s) => ValidateEquals(s == "a3\u044C1\u04362a\022a1a", s, "a3\u044C1\u04362a\022a1a");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_63(string s) => ValidateEquals(s == "3\u0419b30b33231b\u044C", s, "3\u0419b30b33231b\u044C");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_64(string s) => ValidateEquals(s == "2210121\u043613231", s, "2210121\u043613231");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_65(string s) => ValidateEquals(s == "013311aa3203\u04191", s, "013311aa3203\u04191");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_66(string s) => ValidateEquals(s == "12\u0419\u04191\u04192a\u04192\u044Cb\u0419a", s, "12\u0419\u04191\u04192a\u04192\u044Cb\u0419a");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_67(string s) => ValidateEquals(s == "2b1\u041911130221b\u044C", s, "2b1\u041911130221b\u044C");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_68(string s) => ValidateEquals(s == "230110\u04190b3112\u0436", s, "230110\u04190b3112\u0436");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_69(string s) => ValidateEquals(s == "a213\u044Cab121b332", s, "a213\u044Cab121b332");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_70(string s) => ValidateEquals(s == "111a01\u04363121b123", s, "111a01\u04363121b123");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_71(string s) => ValidateEquals(s == "13a322\u04192\u04193b\u0436b0\u0419", s, "13a322\u04192\u04193b\u0436b0\u0419");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_72(string s) => ValidateEquals(s == "\021232b1\u0419aa1032", s, "\021232b1\u0419aa1032");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_73(string s) => ValidateEquals(s == "\u0436\u0419112\u044Cb12\u0419\u044C3b2\u0436", s, "\u0436\u0419112\u044Cb12\u0419\u044C3b2\u0436");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_74(string s) => ValidateEquals(s == "2b\u044C\u044C331bb\023122", s, "2b\u044C\u044C331bb\023122");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_75(string s) => ValidateEquals(s == "a\u043622\u04192203b023b\u044C3", s, "a\u043622\u04192203b023b\u044C3");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_76(string s) => ValidateEquals(s == "a\u0419033\u04363a220\u044C3331", s, "a\u0419033\u04363a220\u044C3331");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_77(string s) => ValidateEquals(s == "20\u0419\u0436a1b1313\u0436\u0419b2a", s, "20\u0419\u0436a1b1313\u0436\u0419b2a");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_78(string s) => ValidateEquals(s == "131\u04191\022\u04362322123", s, "131\u04191\022\u04362322123");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_79(string s) => ValidateEquals(s == "23323b21\u044C11b\u0419321", s, "23323b21\u044C11b\u0419321");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_80(string s) => ValidateEquals(s == "302a\u044C\u0436a3213\u0436a\u04193\u0419\u0436", s, "302a\u044C\u0436a3213\u0436a\u04193\u0419\u0436");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_81(string s) => ValidateEquals(s == "\u043613b00210b1212102", s, "\u043613b00210b1212102");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_82(string s) => ValidateEquals(s == "20320\u04193\u04193\u044C\u04363\u04192122", s, "20320\u04193\u04193\u044C\u04363\u04192122");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_83(string s) => ValidateEquals(s == "0bb23a30ba\u0419b2333\u044C", s, "0bb23a30ba\u0419b2333\u044C");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_84(string s) => ValidateEquals(s == "22122\u044C130230103a2", s, "22122\u044C130230103a2");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_85(string s) => ValidateEquals(s == "\u044C\u044Cba20\u04361\u0436\u044C\u0419\u044Cb\u041931b\u0436", s, "\u044C\u044Cba20\u04361\u0436\u044C\u0419\u044Cb\u041931b\u0436");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_86(string s) => ValidateEquals(s == "bb1\u044C1033b\u04363011b\u043610", s, "bb1\u044C1033b\u04363011b\u043610");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_87(string s) => ValidateEquals(s == "1\u044C320a3a22b3333b13", s, "1\u044C320a3a22b3333b13");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_88(string s) => ValidateEquals(s == "0a22a\u0419\u0436a2222\u043623\u041913", s, "0a22a\u0419\u0436a2222\u043623\u041913");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_89(string s) => ValidateEquals(s == "\u041911\u0419213212\u04361233b23", s, "\u041911\u0419213212\u04361233b23");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_90(string s) => ValidateEquals(s == "32\u044C1\u041903123\u044C011332ab", s, "32\u044C1\u041903123\u044C011332ab");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_91(string s) => ValidateEquals(s == "222\u04362311b133b3\u04363223", s, "222\u04362311b133b3\u04363223");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_92(string s) => ValidateEquals(s == "0111\u044C3002222a3aaaa3", s, "0111\u044C3002222a3aaaa3");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_93(string s) => ValidateEquals(s == "313\u0419213a\u043601a12231a2", s, "313\u0419213a\u043601a12231a2");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_94(string s) => ValidateEquals(s == "1\u0436022\u044C1323b3b3\u0436222\u044C", s, "1\u0436022\u044C1323b3b3\u0436222\u044C");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_95(string s) => ValidateEquals(s == "\u044C023a3b213\u044C033\u043613231", s, "\u044C023a3b213\u044C033\u043613231");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_96(string s) => ValidateEquals(s == "ab2b0b\u044C322300\u04362220\u04362", s, "ab2b0b\u044C322300\u04362220\u04362");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_97(string s) => ValidateEquals(s == "1133\u0419323223\u043631002123", s, "1133\u0419323223\u043631002123");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_98(string s) => ValidateEquals(s == "233\u04360b3\u0419023\u0419\u044Caa\u04363321", s, "233\u04360b3\u0419023\u0419\u044Caa\u04363321");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_99(string s) => ValidateEquals(s == "3\u041911b313323230a02\u041930", s, "3\u041911b313323230a02\u041930");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_100(string s) => ValidateEquals(s == "1\u04362\u0419\u04360131a2\u04362a\u0419\u04193\u044Cb11", s, "1\u04362\u0419\u04360131a2\u04362a\u0419\u04193\u044Cb11");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_101(string s) => ValidateEquals(s == "\u041913303ba3\u044C\u043631a1102222", s, "\u041913303ba3\u044C\u043631a1102222");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_102(string s) => ValidateEquals(s == "32331221\u044C3\u044Cb103212132", s, "32331221\u044C3\u044Cb103212132");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_103(string s) => ValidateEquals(s == "133\u04190332210231331100\u0419", s, "133\u04190332210231331100\u0419");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_104(string s) => ValidateEquals(s == "22221322\u04191133bb0\u04193222", s, "22221322\u04191133bb0\u04193222");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_105(string s) => ValidateEquals(s == "12b011\u04363a1\u04363\u0419\u0419a12\u04190\u044C3\u044C", s, "12b011\u04363a1\u04363\u0419\u0419a12\u04190\u044C3\u044C");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_106(string s) => ValidateEquals(s == "0333\u044C12113\u044C11331\u0436323\u0419\u0436", s, "0333\u044C12113\u044C11331\u0436323\u0419\u0436");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_107(string s) => ValidateEquals(s == "0\u041913a310\u044C12\02\u044C\02320331", s, "0\u041913a310\u044C12\02\u044C\02320331");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_108(string s) => ValidateEquals(s == "022b2\u044C\u04360302b33\u041921\u04361112", s, "022b2\u044C\u04360302b33\u041921\u04361112");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_109(string s) => ValidateEquals(s == "3322\u04362133133b3032\u0419aa12", s, "3322\u04362133133b3032\u0419aa12");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_110(string s) => ValidateEquals(s == "\u0419132\u0419a\u044Cb33a3\u041933\u0419b21a2b2", s, "\u0419132\u0419a\u044Cb33a3\u041933\u0419b21a2b2");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_111(string s) => ValidateEquals(s == "31102113\u041911\u0436b31b\u041912b133", s, "31102113\u041911\u0436b31b\u041912b133");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_112(string s) => ValidateEquals(s == "\u0419\u044C\u0419\u04190\u041903a\023\u044C3311\u044C\u04191323", s, "\u0419\u044C\u0419\u04190\u041903a\023\u044C3311\u044C\u04191323");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_113(string s) => ValidateEquals(s == "212323\u0436a23203bb00\u0436a12\u04363", s, "212323\u0436a23203bb00\u0436a12\u04363");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_114(string s) => ValidateEquals(s == "\u0436\u041931130\u043632322313010aa13", s, "\u0436\u041931130\u043632322313010aa13");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_115(string s) => ValidateEquals(s == "123a\u04362221\022\u043622\u0419021b\u0419\u04190\u0419", s, "123a\u04362221\022\u043622\u0419021b\u0419\u04190\u0419");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_116(string s) => ValidateEquals(s == "211131\u04362213303b1b0231a11", s, "211131\u04362213303b1b0231a11");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_117(string s) => ValidateEquals(s == "\u044C1a\u0419\u0436\u044C0110\u04192b220\u0436\u04363\u044C\u04363\u04361", s, "\u044C1a\u0419\u0436\u044C0110\u04192b220\u0436\u04363\u044C\u04363\u04361");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_118(string s) => ValidateEquals(s == "3\u0436ab2221133331311\023\u0419\u04193\u0436", s, "3\u0436ab2221133331311\023\u0419\u04193\u0436");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_119(string s) => ValidateEquals(s == "21\u041920\02\u044C\u044C333\u044Cb332223\u0419\u04361\u0419", s, "21\u041920\02\u044C\u044C333\u044Cb332223\u0419\u04361\u0419");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_120(string s) => ValidateEquals(s == "1\u04192120a01110\u04191121003a3b33", s, "1\u04192120a01110\u04191121003a3b33");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_121(string s) => ValidateEquals(s == "3021a1\u04191aa1111b22\u0419112\u0419201", s, "3021a1\u04191aa1111b22\u0419112\u0419201");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_122(string s) => ValidateEquals(s == "2b21\u044Ca\u044Cb\023\u041933301\u04193123\u0419\u04361", s, "2b21\u044Ca\u044Cb\023\u041933301\u04193123\u0419\u04361");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_123(string s) => ValidateEquals(s == "2\u04361ba\u0419\u04191a\021\u043623323\u0436b\u0436331\u0436", s, "2\u04361ba\u0419\u04191a\021\u043623323\u0436b\u0436331\u0436");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_124(string s) => ValidateEquals(s == "bab12332\u043631130\u04193230\u044C1011a", s, "bab12332\u043631130\u04193230\u044C1011a");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_125(string s) => ValidateEquals(s == "110a\u044C31\u043633\u044C\u044C33333a2b32\u044C12\u044C", s, "110a\u044C31\u043633\u044C\u044C33333a2b32\u044C12\u044C");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_126(string s) => ValidateEquals(s == "a2\u0436\u041911\u044C1b\u044C312a11a\u044Ca\u044Cb02\u0419b0", s, "a2\u0436\u041911\u044C1b\u044C312a11a\u044Ca\u044Cb02\u0419b0");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_127(string s) => ValidateEquals(s == "32b2\u043612a32a3\u043623\u04361\u044C\u0419bb22213", s, "32b2\u043612a32a3\u043623\u04361\u044C\u0419bb22213");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_128(string s) => ValidateEquals(s == "30\u0436111\u044C11120\u0436\u0436b10212\u0436b\u044C33\u0419", s, "30\u0436111\u044C11120\u0436\u0436b10212\u0436b\u044C33\u0419");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_129(string s) => ValidateEquals(s == "33b1311\u04361\023b\u0436020\u041910b0302\u0436", s, "33b1311\u04361\023b\u0436020\u041910b0302\u0436");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_130(string s) => ValidateEquals(s == "b3122\u0436a12\021123a3130100113\u044C", s, "b3122\u0436a12\021123a3130100113\u044C");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_131(string s) => ValidateEquals(s == "302a1\u0436322\021221\02a1331b2\u0436\u044C1", s, "302a1\u0436322\021221\02a1331b2\u0436\u044C1");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_132(string s) => ValidateEquals(s == "31201322\u0436\u0436\0221\u0419\021\u0419\u044C\u044C32\u041911\u0436", s, "31201322\u0436\u0436\0221\u0419\021\u0419\u044C\u044C32\u041911\u0436");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_133(string s) => ValidateEquals(s == "3b\u0436a132a13ba1311\u04361\u041922\u0419b\u0419a33", s, "3b\u0436a132a13ba1311\u04361\u041922\u0419b\u0419a33");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_134(string s) => ValidateEquals(s == "b33\u0419113\u0419\u0419ab1b332211222\u041932\02", s, "b33\u0419113\u0419\u0419ab1b332211222\u041932\02");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_135(string s) => ValidateEquals(s == "0\u0436333b31b212121b1a\u043602\u0436133111", s, "0\u0436333b31b212121b1a\u043602\u0436133111");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_136(string s) => ValidateEquals(s == "0101\u0419220\u04190\u0436\u04193\u04192abba0b1223aab", s, "0101\u0419220\u04190\u0436\u04193\u04192abba0b1223aab");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_137(string s) => ValidateEquals(s == "2\u0419330b\u0419123\u04362\u043602\u0436212\u044C112111\u04191", s, "2\u0419330b\u0419123\u04362\u043602\u0436212\u044C112111\u04191");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_138(string s) => ValidateEquals(s == "22a\0212a\u044C3b1303\u04193bb2b313\u0419222", s, "22a\0212a\u044C3b1303\u04193bb2b313\u0419222");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_139(string s) => ValidateEquals(s == "2\u044C\u0436133332102222\020\u0419\u0436bb2\022\02", s, "2\u044C\u0436133332102222\020\u0419\u0436bb2\022\02");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_140(string s) => ValidateEquals(s == "2\02321b31123231b2\u0419\u0419122ab\u04192131", s, "2\02321b31123231b2\u0419\u0419122ab\u04192131");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_141(string s) => ValidateEquals(s == "1b021\u044C\u041930a2332\u044C3\u041912231\u0436\u04361a\u0436\u044C1", s, "1b021\u044C\u041930a2332\u044C3\u041912231\u0436\u04361a\u0436\u044C1");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_142(string s) => ValidateEquals(s == "1\u04363\u044C\u044C3\u044C1\u044C1\u044C0\u04361\u0419122132a2\u044C\u044Ca\u04193b", s, "1\u04363\u044C\u044C3\u044C1\u044C1\u044C0\u04361\u0419122132a2\u044C\u044Ca\u04193b");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_143(string s) => ValidateEquals(s == "21bbb31301\u044C3\u0436aa\u04360\u04193323b33\u044C1\u044C1", s, "21bbb31301\u044C3\u0436aa\u04360\u04193323b33\u044C1\u044C1");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_144(string s) => ValidateEquals(s == "a00\u0419\u044C11\u0436\u0436aa321\u044C\u04191\u041931\u0436a21\u04363223", s, "a00\u0419\u044C11\u0436\u0436aa321\u044C\u04191\u041931\u0436a21\u04363223");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_145(string s) => ValidateEquals(s == "3132b0\u0419b3110ab\0201\u04191\u043632222a33\u0436", s, "3132b0\u0419b3110ab\0201\u04191\u043632222a33\u0436");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_146(string s) => ValidateEquals(s == "32b110bb312\u044C02\u04191b2\u041923232\u041912\u044C33", s, "32b110bb312\u044C02\u04191b2\u041923232\u041912\u044C33");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_147(string s) => ValidateEquals(s == "\u0436121bbb\u04192b1\u043612222\u0419\u044C1\u0419b02013\u0436\u044C1", s, "\u0436121bbb\u04192b1\u043612222\u0419\u044C1\u0419b02013\u0436\u044C1");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_148(string s) => ValidateEquals(s == "\u044C1b00a3310231001b1a1\u044C33\u0436\u0436b130\u044C", s, "\u044C1b00a3310231001b1a1\u044C33\u0436\u0436b130\u044C");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_149(string s) => ValidateEquals(s == "\u04363b211b121\u043623b\u044C12a1\u04192\u0419\u043612313a\u0436", s, "\u04363b211b121\u043623b\u044C12a1\u04192\u0419\u043612313a\u0436");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_150(string s) => ValidateEquals(s == "1a3\u0436b31311322\u0436\u044C33213\u04193\u044C13330\u0436a3", s, "1a3\u0436b31311322\u0436\u044C33213\u04193\u044C13330\u0436a3");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_151(string s) => ValidateEquals(s == "b33\u0419b\u04363333233101a33\u04363b231221\u044C11", s, "b33\u0419b\u04363333233101a33\u04363b231221\u044C11");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_152(string s) => ValidateEquals(s == "1\u0419212\u04193\u0436112a31a\u044C\u0436\u044C\u041932\u0436233a32\u04191\u0436", s, "1\u0419212\u04193\u0436112a31a\u044C\u0436\u044C\u041932\u0436233a32\u04191\u0436");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_153(string s) => ValidateEquals(s == "133\u044C02a\u044Ca0\u04193\u0419ab3\u044C1\u04193\u04192a21121210", s, "133\u044C02a\u044Ca0\u04193\u0419ab3\u044C1\u04193\u04192a21121210");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_154(string s) => ValidateEquals(s == "1320ba\u043631b3\u04192\u04191322b113212212331", s, "1320ba\u043631b3\u04192\u04191322b113212212331");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_155(string s) => ValidateEquals(s == "1\u0419a332132\u0436b31\u041933\u041932321\u043631b120\u043603", s, "1\u0419a332132\u0436b31\u041933\u041932321\u043631b120\u043603");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_156(string s) => ValidateEquals(s == "213321a1b3\u0436\u044C3111\u0436\u04192b2\u04193101221\u044C33", s, "213321a1b3\u0436\u044C3111\u0436\u04192b2\u04193101221\u044C33");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_157(string s) => ValidateEquals(s == "2\u04361311a23b2212a\u041921\u041911\u0436b3233bb3a1", s, "2\u04361311a23b2212a\u041921\u041911\u0436b3233bb3a1");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_158(string s) => ValidateEquals(s == "01\u041911113\u044C3\u041932a3\u044C\u0419\u04193\u041932b2ab221310", s, "01\u041911113\u044C3\u041932a3\u044C\u0419\u04193\u041932b2ab221310");
+ [MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_159(string s) => ValidateEquals(s == "a120213b11211\0223223312\u044C\u044C1\u04193222\u0419", s, "a120213b11211\0223223312\u044C\u044C1\u04193222\u0419");
[MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_160(string s) => ValidateEquals(s == "\u9244", s, "\u9244");
[MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_161(string s) => ValidateEquals(s == "\u9244\u9244", s, "\u9244\u9244");
[MethodImpl(MethodImplOptions.NoInlining)] public static void Equals_162(string s) => ValidateEquals(s == "\u9244\u9244\u9244", s, "\u9244\u9244\u9244");
"\0",
"a",
"0",
- "ж",
+ "\u0436",
"3",
"33",
"31",
"12",
"13",
"b12",
- "ж23",
+ "\u043623",
"2a2",
"222",
- "0ь3",
- "bж31",
- "ьЙbЙ",
+ "0\u044C3",
+ "b\u043631",
+ "\u044C\u0419b\u0419",
"b033",
- "311ь",
- "жЙ12",
+ "311\u044C",
+ "\u0436\u041912",
"2011b",
"222b2",
- "aЙ213",
+ "a\u0419213",
"1a131",
- "3232Й",
- "3b0ьжь",
- "213b2Й",
+ "3232\u0419",
+ "3b0\u044C\u0436\u044C",
+ "213b2\u0419",
"b31210",
- "1ж0021",
- "3ь3112",
+ "1\u04360021",
+ "3\u044C3112",
"122b231",
- "03ж32ж3",
- "bb31ж2Й",
- "023bьжЙ",
+ "03\u043632\u04363",
+ "bb31\u04362\u0419",
+ "023b\u044C\u0436\u0419",
"\0232a12",
- "ж13ь11Йь",
- "11ьbb32ь",
- "222Йж3ж3",
- "ж303aЙ12",
- "ьb22322b",
- "a22b10b1Й",
- "3ba2221ь3",
- "жa1Й0b1Й1",
- "a20Йжж1ьь",
- "ьaж32132ь",
- "11111Й3Й12",
- "11Й\02Йb3жж",
- "21bжжж0103",
- "333332aЙ11",
- "Й123112313",
- "12ЙьЙaЙ11ьb",
- "жж22221Й3Й2",
- "ьЙ1bbж3202ж",
- "1bbЙ2Й33Й2ж",
- "2013133ь1bж",
- "23a2\02жa2a13",
- "23Й210Й3a3ж1",
- "32Й2133bb2Й3",
- "Й3bb1ь3bbьb3",
- "a0Йbabж2Й133",
- "320жa22a11ж1b",
- "ь321b3ьЙЙ13Й2",
- "a3ь1ж2a\022a1a",
- "3Йb30b33231bь",
- "2210121ж13231",
- "013311aa3203Й1",
- "12ЙЙ1Й2aЙ2ьbЙa",
- "2b1Й11130221bь",
- "230110Й0b3112ж",
- "a213ьab121b332",
- "111a01ж3121b123",
- "13a322Й2Й3bжb0Й",
- "\021232b1Йaa1032",
- "жЙ112ьb12Йь3b2ж",
- "2bьь331bb\023122",
- "aж22Й2203b023bь3",
- "aЙ033ж3a220ь3331",
- "20Йжa1b1313жЙb2a",
- "131Й1\022ж2322123",
- "23323b21ь11bЙ321",
- "302aьжa3213жaЙ3Йж",
- "ж13b00210b1212102",
- "20320Й3Й3ьж3Й2122",
- "0bb23a30baЙb2333ь",
- "22122ь130230103a2",
- "ььba20ж1жьЙьbЙ31bж",
- "bb1ь1033bж3011bж10",
- "1ь320a3a22b3333b13",
- "0a22aЙжa2222ж23Й13",
- "Й11Й213212ж1233b23",
- "32ь1Й03123ь011332ab",
- "222ж2311b133b3ж3223",
- "0111ь3002222a3aaaa3",
- "313Й213aж01a12231a2",
- "1ж022ь1323b3b3ж222ь",
- "ь023a3b213ь033ж13231",
- "ab2b0bь322300ж2220ж2",
- "1133Й323223ж31002123",
- "233ж0b3Й023Йьaaж3321",
- "3Й11b313323230a02Й30",
- "1ж2Йж0131a2ж2aЙЙ3ьb11",
- "Й13303ba3ьж31a1102222",
- "32331221ь3ьb103212132",
- "133Й0332210231331100Й",
- "22221322Й1133bb0Й3222",
- "12b011ж3a1ж3ЙЙa12Й0ь3ь",
- "0333ь12113ь11331ж323Йж",
- "0Й13a310ь12\02ь\02\02320331",
- "022b2ьж0302b33Й21ж1112",
- "3322ж2133133b3032Йaa12",
- "Й132Йaьb33a3Й33Йb21a2b2",
- "31102113Й11жb31bЙ12b133",
- "ЙьЙЙ0Й03a\023ь3311ьЙ1323",
- "212323жa23203bb00жa12ж3",
- "жЙ31130ж32322313010aa13",
- "123aж2221\022ж22Й021bЙЙ0Й",
- "211131ж2213303b1b0231a11",
- "ь1aЙжь0110Й2b220жж3ьж3ж1",
- "3жab2221133331311\023ЙЙ3ж",
- "21Й20\02ьь333ьb332223Йж1Й",
- "1Й2120a01110Й1121003a3b33",
- "3021a1Й1aa1111b22Й112Й201",
- "2b21ьaьb\023Й33301Й3123Йж1",
- "2ж1baЙЙ1a\021ж23323жbж331ж",
- "bab12332ж31130Й3230ь1011a",
- "110aь31ж33ьь33333a2b32ь12ь",
- "a2жЙ11ь1bь312a11aьaьb02Йb0",
- "32b2ж12a32a3ж23ж1ьЙbb22213",
- "30ж111ь11120жжb10212жbь33Й",
- "33b1311ж1\023bж020Й10b0302ж",
- "b3122жa12\021123a3130100113ь",
- "302a1ж322\021221z2a1331b2жь1",
- "31201322жж\0221Йz21Йьь32Й11ж",
- "3bжa132a13ba1311ж1Й22ЙbЙa33",
- "b33Й113ЙЙab1b332211222Й32\02",
- "0ж333b31b212121b1aж02ж133111",
- "0101Й220Й0жЙ3Й2abba0b1223aa\0",
- "2Й330bЙ123ж2ж02ж212ь112111Й1",
- "22a\0212aь3b1303Й3bb2b313Й222",
- "2ьж133332102222\020Йжbb2\022\02",
- "2\02321b31123231b2ЙЙ122abЙ2131",
- "1b021ьЙ30a2332ь3Й12231жж1aжь1",
- "1ж3ьь3ь1ь1ь0ж1Й122132a2ььaЙ3b",
- "21bbb31301ь3жaaж0Й3323b33ь1ь1",
- "a00Йь11жжaa321ьЙ1Й31жa21ж3223",
- "3132b0Йb3110ab\0201Й1ж32222a33ж",
- "32b110bb312ь02Й1b2Й23232Й12ь33",
- "ж121bbbЙ2b1ж12222Йь1Йb02013жь1",
- "ь1b00a3310231001b1a1ь33жжb130ь",
- "ж3b211b121ж23bь12a1Й2Йж12313aж",
- "1a3жb31311322жь33213Й3ь13330жa3",
- "b33Йbж3333233101a33ж3b231221ь11",
- "1Й212Й3ж112a31aьжьЙ32ж233a32Й1ж",
- "133ь02aьa0Й3Йab3ь1Й3Й2a21121210",
- "1320baж31b3Й2Й1322b113212212331",
- "1Йa332132жb31Й33Й32321ж31b120ж03",
- "213321a1b3жь3111жЙ2b2Й3101221ь33",
- "2ж1311a23b2212aЙ21Й11жb3233bb3a1",
- "01Й11113ь3Й32a3ьЙЙ3Й32b2ab221310",
- "a120213b11211\0223223312ьь1Й3222Й",
+ "\u043613\u044C11\u0419\u044C",
+ "11\u044Cbb32\u044C",
+ "222\u0419\u04363\u04363",
+ "\u0436303a\u041912",
+ "\u044Cb22322b",
+ "a22b10b1\u0419",
+ "3ba2221\u044C3",
+ "\u0436a1\u04190b1\u04191",
+ "a20\u0419\u0436\u04361\u044C\u044C",
+ "\u044Ca\u043632132\u044C",
+ "11111\u04193\u041912",
+ "11\u0419\02\u0419b3\u0436\u0436",
+ "21b\u0436\u0436\u04360103",
+ "333332a\u041911",
+ "\u0419123112313",
+ "12\u0419\u044C\u0419a\u041911\u044Cb",
+ "\u0436\u043622221\u04193\u04192",
+ "\u044C\u04191bb\u04363202\u0436",
+ "1bb\u04192\u041933\u04192\u0436",
+ "2013133\u044C1b\u0436",
+ "23a2\02\u0436a2a13",
+ "23\u0419210\u04193a3\u04361",
+ "32\u04192133bb2\u04193",
+ "\u04193bb1\u044C3bb\u044Cb3",
+ "a0\u0419bab\u04362\u0419133",
+ "320\u0436a22a11\u04361b",
+ "\u044C321b3\u044C\u0419\u041913\u04192",
+ "a3\u044C1\u04362a\022a1a",
+ "3\u0419b30b33231b\u044C",
+ "2210121\u043613231",
+ "013311aa3203\u04191",
+ "12\u0419\u04191\u04192a\u04192\u044Cb\u0419a",
+ "2b1\u041911130221b\u044C",
+ "230110\u04190b3112\u0436",
+ "a213\u044Cab121b332",
+ "111a01\u04363121b123",
+ "13a322\u04192\u04193b\u0436b0\u0419",
+ "\021232b1\u0419aa1032",
+ "\u0436\u0419112\u044Cb12\u0419\u044C3b2\u0436",
+ "2b\u044C\u044C331bb\023122",
+ "a\u043622\u04192203b023b\u044C3",
+ "a\u0419033\u04363a220\u044C3331",
+ "20\u0419\u0436a1b1313\u0436\u0419b2a",
+ "131\u04191\022\u04362322123",
+ "23323b21\u044C11b\u0419321",
+ "302a\u044C\u0436a3213\u0436a\u04193\u0419\u0436",
+ "\u043613b00210b1212102",
+ "20320\u04193\u04193\u044C\u04363\u04192122",
+ "0bb23a30ba\u0419b2333\u044C",
+ "22122\u044C130230103a2",
+ "\u044C\u044Cba20\u04361\u0436\u044C\u0419\u044Cb\u041931b\u0436",
+ "bb1\u044C1033b\u04363011b\u043610",
+ "1\u044C320a3a22b3333b13",
+ "0a22a\u0419\u0436a2222\u043623\u041913",
+ "\u041911\u0419213212\u04361233b23",
+ "32\u044C1\u041903123\u044C011332ab",
+ "222\u04362311b133b3\u04363223",
+ "0111\u044C3002222a3aaaa3",
+ "313\u0419213a\u043601a12231a2",
+ "1\u0436022\u044C1323b3b3\u0436222\u044C",
+ "\u044C023a3b213\u044C033\u043613231",
+ "ab2b0b\u044C322300\u04362220\u04362",
+ "1133\u0419323223\u043631002123",
+ "233\u04360b3\u0419023\u0419\u044Caa\u04363321",
+ "3\u041911b313323230a02\u041930",
+ "1\u04362\u0419\u04360131a2\u04362a\u0419\u04193\u044Cb11",
+ "\u041913303ba3\u044C\u043631a1102222",
+ "32331221\u044C3\u044Cb103212132",
+ "133\u04190332210231331100\u0419",
+ "22221322\u04191133bb0\u04193222",
+ "12b011\u04363a1\u04363\u0419\u0419a12\u04190\u044C3\u044C",
+ "0333\u044C12113\u044C11331\u0436323\u0419\u0436",
+ "0\u041913a310\u044C12\02\u044C\02\02320331",
+ "022b2\u044C\u04360302b33\u041921\u04361112",
+ "3322\u04362133133b3032\u0419aa12",
+ "\u0419132\u0419a\u044Cb33a3\u041933\u0419b21a2b2",
+ "31102113\u041911\u0436b31b\u041912b133",
+ "\u0419\u044C\u0419\u04190\u041903a\023\u044C3311\u044C\u04191323",
+ "212323\u0436a23203bb00\u0436a12\u04363",
+ "\u0436\u041931130\u043632322313010aa13",
+ "123a\u04362221\022\u043622\u0419021b\u0419\u04190\u0419",
+ "211131\u04362213303b1b0231a11",
+ "\u044C1a\u0419\u0436\u044C0110\u04192b220\u0436\u04363\u044C\u04363\u04361",
+ "3\u0436ab2221133331311\023\u0419\u04193\u0436",
+ "21\u041920\02\u044C\u044C333\u044Cb332223\u0419\u04361\u0419",
+ "1\u04192120a01110\u04191121003a3b33",
+ "3021a1\u04191aa1111b22\u0419112\u0419201",
+ "2b21\u044Ca\u044Cb\023\u041933301\u04193123\u0419\u04361",
+ "2\u04361ba\u0419\u04191a\021\u043623323\u0436b\u0436331\u0436",
+ "bab12332\u043631130\u04193230\u044C1011a",
+ "110a\u044C31\u043633\u044C\u044C33333a2b32\u044C12\u044C",
+ "a2\u0436\u041911\u044C1b\u044C312a11a\u044Ca\u044Cb02\u0419b0",
+ "32b2\u043612a32a3\u043623\u04361\u044C\u0419bb22213",
+ "30\u0436111\u044C11120\u0436\u0436b10212\u0436b\u044C33\u0419",
+ "33b1311\u04361\023b\u0436020\u041910b0302\u0436",
+ "b3122\u0436a12\021123a3130100113\u044C",
+ "302a1\u0436322\021221z2a1331b2\u0436\u044C1",
+ "31201322\u0436\u0436\0221\u0419z21\u0419\u044C\u044C32\u041911\u0436",
+ "3b\u0436a132a13ba1311\u04361\u041922\u0419b\u0419a33",
+ "b33\u0419113\u0419\u0419ab1b332211222\u041932\02",
+ "0\u0436333b31b212121b1a\u043602\u0436133111",
+ "0101\u0419220\u04190\u0436\u04193\u04192abba0b1223aa\0",
+ "2\u0419330b\u0419123\u04362\u043602\u0436212\u044C112111\u04191",
+ "22a\0212a\u044C3b1303\u04193bb2b313\u0419222",
+ "2\u044C\u0436133332102222\020\u0419\u0436bb2\022\02",
+ "2\02321b31123231b2\u0419\u0419122ab\u04192131",
+ "1b021\u044C\u041930a2332\u044C3\u041912231\u0436\u04361a\u0436\u044C1",
+ "1\u04363\u044C\u044C3\u044C1\u044C1\u044C0\u04361\u0419122132a2\u044C\u044Ca\u04193b",
+ "21bbb31301\u044C3\u0436aa\u04360\u04193323b33\u044C1\u044C1",
+ "a00\u0419\u044C11\u0436\u0436aa321\u044C\u04191\u041931\u0436a21\u04363223",
+ "3132b0\u0419b3110ab\0201\u04191\u043632222a33\u0436",
+ "32b110bb312\u044C02\u04191b2\u041923232\u041912\u044C33",
+ "\u0436121bbb\u04192b1\u043612222\u0419\u044C1\u0419b02013\u0436\u044C1",
+ "\u044C1b00a3310231001b1a1\u044C33\u0436\u0436b130\u044C",
+ "\u04363b211b121\u043623b\u044C12a1\u04192\u0419\u043612313a\u0436",
+ "1a3\u0436b31311322\u0436\u044C33213\u04193\u044C13330\u0436a3",
+ "b33\u0419b\u04363333233101a33\u04363b231221\u044C11",
+ "1\u0419212\u04193\u0436112a31a\u044C\u0436\u044C\u041932\u0436233a32\u04191\u0436",
+ "133\u044C02a\u044Ca0\u04193\u0419ab3\u044C1\u04193\u04192a21121210",
+ "1320ba\u043631b3\u04192\u04191322b113212212331",
+ "1\u0419a332132\u0436b31\u041933\u041932321\u043631b120\u043603",
+ "213321a1b3\u0436\u044C3111\u0436\u04192b2\u04193101221\u044C33",
+ "2\u04361311a23b2212a\u041921\u041911\u0436b3233bb3a1",
+ "01\u041911113\u044C3\u041932a3\u044C\u0419\u04193\u041932b2ab221310",
+ "a120213b11211\0223223312\u044C\u044C1\u04193222\u0419",
};
}
"aaaaaa-aaaaa",
"aaaaaaaaaaaa",
"aaaaaaaaaaaaa",
- "aaaaaaaaaжжaaa",
+ "aaaaaaaaa\u0436\u0436aaa",
"aaaaaaaaaaaaaaa",
"aaaAAAaaaaaazzz",
"aaaaaaaaaaaaaaaa",
- "aaaaaaaaaaaaжaaaa",
+ "aaaaaaaaaaaa\u0436aaaa",
"aaaaaaAAAAaaaaaaa",
"aaaaaaaaaaaaaaaaaa",
"aaaaaaaggggggggggaa",
"aaaaaaaaaaaaaaaaaaaaa",
"aaaaaaAAAAaaaaaaaaaaaa",
"aaaaaaaaaaaaaaaaaaaaaa\0",
- "aaaччччччччччaaaaжжaaaaa",
+ "aaa\u0447\u0447\u0447\u0447\u0447\u0447\u0447\u0447\u0447\u0447aaaa\u0436\u0436aaaaa",
"aaaaaaaaaaaaaaaaaaaaaaaaa",
"gggggggggggaaaaaaaaaaaaaaa",
"aaaaaaaaaaaaaaaaaaaaaaaaaaa",
// Add more test input - uppercase, lowercase, replace some chars
testDataList.Add(td.ToUpper());
testDataList.Add(td.Replace('a', 'b'));
- testDataList.Add(td.Replace('a', 'Ф'));
+ testDataList.Add(td.Replace('a', '\u0424'));
testDataList.Add(td.ToLower());
}
public static class Tests_len14_9
{
- const string cns = "aaaaaaaaaжжaaa";
+ const string cns = "aaaaaaaaa\u0436\u0436aaa";
[MethodImpl(Utils.NoOpt)]public static bool Test_ref_0(string s) => s == Utils.Var(cns);
[MethodImpl(Utils.Opt)] public static bool Test_tst_0(string s) => s == cns;
[MethodImpl(Utils.NoOpt)]public static bool Test_ref_1(string s) => Utils.Var(cns) == s;
public A() {}
}
-public class Hello<liıİ>
+public class Hello<li\u0131\u0130>
{
- public liıİ a;
- public Hello (liıİ t)
+ public li\u0131\u0130 a;
+ public Hello (li\u0131\u0130 t)
{
a = t;
Console.WriteLine (a.ToString ());
}
- public один InstanceMethod<один> () where один : new()
+ public \u043E\u0434\u0438\u043D InstanceMethod<\u043E\u0434\u0438\u043D> () where \u043E\u0434\u0438\u043D : new()
{
- return new один();
+ return new \u043E\u0434\u0438\u043D();
}
}
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
-var type = Type.GetType("_测试数据记录仪_Iiİı_åäö_Controller_DataLogger1_log_all_", false);
+var type = Type.GetType("_\u6D4B\u8BD5\u6570\u636E\u8BB0\u5F55\u4EEA_Ii\u0130\u0131_\u00E5\u00E4\u00F6_Controller_DataLogger1_log_all_", false);
var obj = Activator.CreateInstance(type!);
Console.WriteLine(obj?.GetType().Name);
return 100;
-public class _测试数据记录仪_Iiİı_åäö_Controller_DataLogger1_log_all_
+public class _\u6D4B\u8BD5\u6570\u636E\u8BB0\u5F55\u4EEA_Ii\u0130\u0131_\u00E5\u00E4\u00F6_Controller_DataLogger1_log_all_
{
}
/*
* Ensure that a key that has no managed references to it gets automatically removed from the
- * dictionary after GC happens. Also make sure the value gets gc\92d as well.
+ * dictionary after GC happens. Also make sure the value gets gc'd as well.
*/
public static void TestKeyWithNoReferences_Pass1(int length)
{
GC.Collect();
- // note, this assignment will prevent the object from being collected if it isn\92t already
+ // note, this assignment will prevent the object from being collected if it isn't already
for (int i = 0; i < length; i++)
{
Object targetKey = weakRefKeyArr[i].Target;
* Ensure that a key whose value has a reference to the key or a reference to another object
* which has a reference to the key, gets automatically removed from the dictionary after GC
* happens (provided there are no references to the value outside the dictionary.)
- * Also make sure the value gets gc\92d as well.
+ * Also make sure the value gets gc'd as well.
*
* In this case we pass the same string array to the function, so keys and values have references to each other
* (But only within the dictionary)
GC.Collect();
- // note, this assignment will prevent the object from being collected if it isn\92t already
+ // note, this assignment will prevent the object from being collected if it isn't already
for (int i = 0; i < length; i++)
{
Object targetKey = weakRefKeyArr[i].Target;
// check that all other objects were collected except for the 3 above
- // note, this assignment will prevent the object from being collected if it isn\92t already
+ // note, this assignment will prevent the object from being collected if it isn't already
for (int i = 0; i < length; i++)
{
Object targetKey = weakRefKeyArr[i].Target;
projects / platform / upstream / dotnet / runtime.git / commitdiff