Assert.AreEqual schlägt fehl, auch wenn erwartet und tatsächlich sind die gleichen

Question

Ich habe den folgenden Test, der scheint, die gleichen Zeichenfolgen aber Assert.AreEqual schlägt fehl.

[TestMethod] 
public void Decompressed_test_should_equal_to_text_before_compression() 
{ 
    TextCompressor compressor = new TextCompressor(); 
    Random r = new Random((int)DateTime.Now.Ticks); 

    for (int i = 500; i < 1500; i++) 
    { 
     char[] testArray = new char[i]; 

     for (int j = 0; j < i; j++) 
     {      
      char randomChar = (char)(r.Next(256, 65536)); 
      testArray[j] = randomChar; 
     } 
     string testString = new String(testArray); 
     string compressed = compressor.Compress(testString); 
     string decompressed = compressor.Decompress(compressed); 

     Assert.AreEqual(testString.Length, decompressed.Length); 
     Assert.AreEqual(testString, decompressed, false, CultureInfo.InvariantCulture); 
    } 
} 

compressor.Compress und compressor.Decompress hat einige Kompression und Dekompression mit GZipStream.

Es passiert, wenn ich versuche (65, 90) statt (256, 65536), also ich vermute, es hat etwas mit Unicode zu tun. Ich habe CurrentCulture und überhaupt keine Kultur anstelle von InvariantCulture ausprobiert und es schlägt immer noch fehl. Die resultierenden Zeichenfolgen scheinen jedoch identisch zu sein:

Assert.AreEqual fehlgeschlagen.

Erwartet:

< ☔ ฺ 疉 鎷 얚 ᧏ 跨 꿌 沩 얫 嘹 ֨ ز 항 們 嵜 浮 䑹 شم 靄  斳 薃 픢 萁 ⯬ 쫎 ʛ⫕ 蝺 ꄗ 穌 넢  뇌 䶆멊 큀퉆  䐫 ̥ 괊 ⑆ 놸  僥 ̅ᵀ 㣚 ꢅ 뺓 䇚 녚 伀 讍 홬 䈕 캾 撏 Ჴ 孢 黮 摠 뮡  䌦 윃 ᬳ 狚 䆙 툾훶 䏤 ꛈṻ⟧㉖ 鮸 蒵 萗 냤 퇅서 㪨 瀲 鰪残 䓴 ۇ 넃 櫜 㑦 䢻 쮓죣 䕱 䶘 㴝 姳 뿝 嘼 ᷨ 㗬 꺬  櫣 涷 ꠶ 浒 껅 က 㷕 䩉  毎 覛 ⧹ 䮯 嬇 힚 艐 Ὑ 쇕횻 鸙 蹻 硐  䈆 쓖 ⸛ 錼 鰙 ኰ乒 ֐ ⺴ 썓힠 䵓 ꅄ ⵈ 桃 桃 枟 枟 ⏠ ⏠  琖 琖 琖 琖 琖 㪿 㪿 㪿 㪿 㪿 㪿 㪿 㪿 㪿 㪿 㪿 㪿 㪿 㪿 㪿 㪿ㅞ ⤩ 㥍 車 䎘 磛 磛 蚾 ㅸ 떦 蝳 蝳 奪 奪 奪 奪 奪 奪 奪 奪 奪 奪 奪 奪 奪 奪 奪硼 佑 烑 䳘 핬 溴 墽 炁 炁 ࣘ ࣘ 䚝 䚝 䚝 䚝 䚝 䚝 䚝 䚝 䚝 䚝 䚝 䚝 䚝 䚝 䚝 䚝 䚝 䚝 䚝 䚝 䚝 䚝 䚝 䚝 䚝 䚝 䚝! ⩏￸ 鍁 Ꮨ䷇ 쁐쨒 ʊ 쪦 鄭 借 滋 铆 ᮉ 嚃 ᩨ⶝ ိ  펇 ꮼ 뇄 』ᰉ 㕾 枒 鯅 蛺  䠿 櫄 築 픆 车 똅렬 ㈆ّ Ἃ 荞 괋  랆 偦 뤰 䝷 핸 ⹝ 屑 素 蝨怀 猔 勛 碉 睹 睹 Ⓥ Ⓥ ಗ    뾿 䦗 䦗 䦗 䦗 䦗 䦗 䦗 䦗 䦗 䦗 䦗 䦗 䦗 䦗 䦗 䦗 䦗 䦗 䦗 䦗 䦗 䦗 䦗 䦗跠 﨔 膉 邘 ⋫ 吪 멚 埣 埣 ꯕ ꯕ 谲 谲 谲 谲 谲 谲 谲 谲 谲 谲 谲 谲 谲 谲 谲 谲 谲 谲 谲 谲 谲 谲 谲 谲 谲 谲 谲䕱 遲 䩢 䩢 뭯 뭯 䬾 갭 갭 䕱 䕱 䕱 䕱 䕱 䕱 䕱 䕱 䕱 䕱 䕱 䕱 䕱 䕱 䕱 䕱 䕱 䕱 䕱 䕱 䕱 䕱.

Aktuell:

< ☔ ฺ 疉 鎷 얚 ᧏ 跨 꿌 沩 얫 嘹 ֨ ز 항 們 嵜 浮 䑹 شم 靄  斳 薃 픢 萁 ⯬ 쫎 ʛ⫕ 蝺 ꄗ 穌 넢  뇌 䶆멊 큀퉆  䐫 ̥ 괊 ⑆ 놸  僥 ̅ᵀ 㣚 ꢅ 뺓 䇚 녚 伀 讍 홬 䈕 캾 撏 Ჴ 孢 黮 摠 뮡  䌦 윃 ᬳ 狚 䆙 툾훶 䏤 ꛈṻ⟧㉖ 鮸 蒵 萗 냤 퇅서 㪨 瀲 鰪残 䓴 ۇ 넃 櫜 㑦 䢻 쮓죣 䕱 䶘 㴝 姳 뿝 嘼 ᷨ 㗬 꺬  櫣 涷 ꠶ 浒 껅 က 㷕 䩉  毎 覛 ⧹ 䮯 嬇 힚 艐 Ὑ 쇕횻 鸙 蹻 硐  䈆 쓖 ⸛ 錼 鰙 ኰ乒 ֐ ⺴ 썓힠 䵓 ꅄ ⵈ 桃 桃 枟 枟 ⏠ ⏠  琖 琖 琖 琖 琖 㪿 㪿 㪿 㪿 㪿 㪿 㪿 㪿 㪿 㪿 㪿 㪿 㪿 㪿 㪿 㪿ㅞ ⤩ 㥍 車 䎘 磛 蚾 蚾 ㅸ ㅸ 蝳 蝳 騑 騑 騑 騑 騑 騑 騑 騑 騑 騑 騑 騑 騑 騑 騑硼 佑 烑 䳘 핬 溴 墽 炁 炁 ࣘ ࣘ 䚝 䚝 䚝 䚝 䚝 䚝 䚝 䚝 䚝 䚝 䚝 䚝 䚝 䚝 䚝 䚝 䚝 䚝 䚝 䚝 䚝 䚝 䚝 䚝 䚝 䚝 䚝! ⩏￸ 鍁 Ꮨ䷇ 쁐쨒 ʊ 쪦 鄭 借 滋 铆 ᮉ 嚃 ᩨ⶝ ိ  펇 ꮼ 뇄 』ᰉ 㕾 枒 鯅 蛺  䠿 櫄 築 픆 车 똅렬 ㈆ّ Ἃ 荞 괋  랆 偦 뤰 䝷 핸 ⹝ 屑 素 蝨怀 猔 勛 碉 睹 睹 Ⓥ Ⓥ ಗ    뾿 䦗 䦗 䦗 䦗 䦗 䦗 䦗 䦗 䦗 䦗 䦗 䦗 䦗 䦗 䦗 䦗 䦗 䦗 䦗 䦗 䦗 䦗 䦗 䦗跠 﨔 膉 痹 邘 ⋫ 吪 멚 埣 ꯕ 扌 옘 广  犵 肖 街  㶕 畅 몡 ↇ꠫ 襤 픧 ၥ 帻 놤 ਰ 惘 똞 颤 糴 쫼 鿋 䬝 穫  ⺁ 峁 踷 锝  副 鰀 嗊 ⹀ 谲䕱 遲 䩢 䩢 뭯 뭯 䬾 갭 갭 䕱 䕱 䕱 䕱 䕱 䕱 䕱 䕱 䕱 䕱 䕱 䕱 䕱 䕱 䕱 䕱 䕱 䕱 䕱 䕱 䕱 䕱.

Was fehlt mir?

Answer 1

(char)(r.Next(256, 65536)) können ungültige Zeichenkombinationen erzeugen, die zu illegalem Text führen, sodass Sie sie nicht zum Erstellen von Testinhalten verwenden können. Dies kann auch dann passieren, wenn der Cast gültig ist und ein gültiges Zeichen erzeugt wird. Ein Beispiel sind Surrogate in U + D800 bis U + DFFF, aber wahrscheinlich gibt es andere.

Wenn Sie Beispieltext aus allen Unicode-Bereichen generieren möchten, müssen Sie bei der Erstellung Unicode beachten und nicht nur zufällig nach char. (Ich glaube, Sie auf diese treffen, wenn Sie in der Frage festgestellt, dass es funktioniert, wenn Sie einen engen Bereich für die Zufallszahl geliefert.)

Answer 2

Verwenden Sie byte nicht char.

Ihre Compress/Decompress Methoden sollten ein byte[] Array nehmen, und was auch immer sie anruft sollten Ihre Unicode-Daten lesen und übersetzen, bevor Sie sie aufrufen.

Sie wissen, dass ab .NET 2.0 die Klasse GZipStream?

Answer 3

einige Experimente gemacht:

string testString = new String(testArray); 
string anotherString = new String(testArray); 
Assert.AreEqual(testString.Length, anotherString.Length); 
Assert.AreEqual(testString, anotherString, false, CultureInfo.InvariantCulture); 

Dies ohne Kompression ist. Es funktioniert gut.

Ich schlage vor, Sie Ihren Test, dies zu ändern:

for (int i = 256; i < 65536; i++) 
{ 
    string testString = new String((char)(i), 2); 

    string compressed = compressor.Compress(testString); 
    string decompressed = compressor.Decompress(compressed); 

    Assert.AreEqual(testString.Length, decompressed.Length); 
    Assert.AreEqual(testString, decompressed, false, CultureInfo.InvariantCulture); 
} 

Diese Tests genau ein Zeichen in einer Zeit, Sie haben keine Zufallswerte (kein „manchmal Werk“ Problem) und Sie werden sehen, ob es eine bestimmte Art von Zeichen gibt, die nicht funktioniert.

Answer 4

Ich habe den gleichen Test für die Verschlüsselung/Entschlüsselung.

Dichotomie Verwendung habe ich festgestellt, dass jede Zeichenfolge „Surrogates Codepunkte“ enthält, die im Unicode-Zeichen Bereich U + 55296 bis U + 57343 wird unter Verwendung von nicht Assert.AreEqual

so die breitesten Bereiche Sie verwenden können, sind:

char randomChar = (char)(r.Next(0, 55295)); 

und

char randomChar = (char)(r.Next(57344, 65535));