Assert.AreEqual échoue même si attendu et réel sont les mêmes

Question

J'ai le test suivant qui semble produire les mêmes chaînes mais Assert.AreEqual échoue.

[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 et compressor.Decompress fait un peu la compression et la décompression avec GZipStream.

Il passe si j'essaie (65, 90) au lieu de (256, 65536) donc je devine qu'il a quelque chose à voir avec unicode. J'ai essayé CurrentCulture et aucune culture du tout au lieu de InvariantCulture et il échoue toujours. Mais les chaînes résultantes semblent être les mêmes:

Échec d'Assert.AreEqual.

attendu:

< ☔ ฺ 疉 鎷 얚 ᧏ 跨 꿌 沩 얫 嘹 ֨ ز 항 們 嵜 浮 䑹 شم 靄  斳 薃 픢 萁 ⯬ 쫎 ʛ⫕ 蝺 ꄗ 穌 넢  뇌 䶆멊 큀퉆  䐫 괊 ⑆ 놸  僥 僥 ̅ᵀ 뺓 뺓 䇚 䇚 讍 홬 홬 홬 撏 Ჴ Ჴ Ჴ Ჴ    윃 狚 䆙 䆙 䏤 䏤 鮸 鮸 鮸 鮸 鮸 㪨 㪨 㪨 瀲 瀲残 䓴 ۇ 넃 㑦 䢻 䕱 䶘 䶘 䶘 㴝 嘼 嘼 ᷨ ᷨ 㗬 櫣 櫣 涷 涷 က က က 㷕 ⧹ ⧹ ⧹ ⧹ 艐 Ὑ Ὑ Ὑ 鸙 蹻 硐 硐 硐 硐 硐 錼 錼 鰙 鰙乒 ֐ ⺴ 썓힠 䵓 ⵈ ⵈ 桃 ⏠ ⏠   琖 琖 琖 琖 琖 琖 琖 琖   ᫇﯎ 蕱 蕱 蕱 䙠 䙠 ⃑ꦴ ⃑ꦴ ⃑ꦴ ⃑ꦴ 麝 熪 熪 熪 뚭 뚭 뚭 钮 钮 钮 ⡃ ⡃ ㅞ ⤩ 㥍 車 磛 蚾 ㅸ 擫 떦 蝳 分 鰽 ꭍ 튘폻 튘폻 ⥽ⳉ ⹼ 驿 똮 ᛼ ᛼ 룴 ꣜ ꣜ ꣜ ꣜ ᵸᮄ ᵸᮄ 杗 杗 杗硼 佑 烑 鄗 핬 溴 墽 炁 ࣘ ヲ ヲ 栥 斗 斗 狹 狹 嬒 嬒 嬒 嬒 䎐 䎐 䎐 䎐 貇 뢸 䖝 䖝 䖝 䵱 䵱 꽔븽 䢴 䢴 䢴 䢴 靔 靔 靔 临 临 临! ⩏￸ 鍁 Ꮨ䷇ 쁐쨒 ʊ 쪦 鄭 滋 滋 滋 铆 嚃 ိ ိ ိ 펇 뇄 」」 」鯅 蛺 蛺  픆 픆 车 똅렬 荞 荞 荞   랆 偦 偦 偦 偦 屑 屑 素 素 素怀 猔 勛 碉 퀪 Ⓥ 䍙 䍙 ಗ 뾿 뾿 谢 ز ز ز ز ز ز ز ز 籍 籍 駡 駡 駡 暷 ᜝ ᜝ ᜝ ᜝ ᜝ 䁆 䁆 䁆 䁆 䁆 䁆 옭 옭 옭 螶 螶 螶跠 﨔 膉 痹 ⋫ 吪 멚 埣 ꯕ 扌 扌 옘 犵 犵 肖 肖 畅 畅 畅 畅 ၥ ၥ ၥ ၥ 帻 똞 똞 똞 颤 䬝 䬝 䬝 ⺁ ⺁ 峁 踷 踷 踷 踷 嗊 嗊 嗊 ⹀ ⹀  遲 䩢 푑팾 뭯 ዇ࣷ䷴ ዇ࣷ䷴ 䬾 갭 魨 魨 魨 㵻 ᣄⲪ ᣄⲪ ᣄⲪ ᣄⲪ 㥨 㥨 몙 큤 큤 큤 ꢡ ꢡ ꢡ 웼 㢓 吋 䂃 䂃 䨠 䕱.

réelle:

< ☔ ฺ 疉 鎷 얚 ᧏ 跨 꿌 沩 얫 嘹 ֨ ز 항 們 嵜 浮 䑹 شم 靄  斳 薃 픢 萁 ⯬ 쫎 ʛ⫕ 蝺 ꄗ 穌 넢  뇌 䶆멊 큀퉆  䐫 괊 ⑆ 놸  僥 僥 ̅ᵀ 뺓 뺓 䇚 䇚 讍 홬 홬 홬 撏 Ჴ Ჴ Ჴ Ჴ    윃 狚 䆙 䆙 䏤 䏤 鮸 鮸 鮸 鮸 鮸 㪨 㪨 㪨 瀲 瀲残 䓴 ۇ 넃 㑦 䢻 䕱 䶘 䶘 䶘 㴝 嘼 嘼 ᷨ ᷨ 㗬 櫣 櫣 涷 涷 က က က 㷕 ⧹ ⧹ ⧹ ⧹ 艐 Ὑ Ὑ Ὑ 鸙 蹻 硐 硐 硐 硐 硐 錼 錼 鰙 鰙乒 ֐ ⺴ 썓힠 䵓 ⵈ ⵈ 桃 ⏠ ⏠   琖 琖 琖 琖 琖 琖 琖 琖   ᫇﯎ 蕱 蕱 蕱 䙠 䙠 ⃑ꦴ ⃑ꦴ ⃑ꦴ ⃑ꦴ 麝 熪 熪 熪 뚭 뚭 뚭 钮 钮 钮 ⡃ ⡃ ㅞ ⤩ 㥍 車 磛 蚾 ㅸ 擫 떦 蝳 分 鰽 䠺 튘폻 ⥽ⳉ ⥽ⳉ 历 驿 ⯴⋟Ḋ ⯴⋟Ḋ ᛼ ꣜ 墭 墭 墭 墭 墭 杗 杗 杗 奪 奪硼 佑 烑 鄗 핬 溴 墽 炁 ࣘ ヲ ヲ 栥 斗 斗 狹 狹 嬒 嬒 嬒 嬒 䎐 䎐 䎐 䎐 貇 뢸 䖝 䖝 䖝 䵱 䵱 꽔븽 䢴 䢴 䢴 䢴 靔 靔 靔 临 临! ⩏￸ 鍁 Ꮨ䷇ 쁐쨒 ʊ 쪦 鄭 滋 滋 滋 铆 嚃 ိ ိ ိ 펇 뇄 」」 」鯅 蛺 蛺  픆 픆 车 똅렬 荞 荞 荞   랆 偦 偦 偦 偦 屑 屑 素 素 素怀 猔 勛 碉 퀪 Ⓥ 䍙 䍙 ಗ 뾿 뾿 谢 ز ز ز ز ز ز ز ز 籍 籍 駡 駡 駡 暷 ᜝ ᜝ ᜝ ᜝ ᜝ 䁆 䁆 䁆 䁆 䁆 䁆 옭 옭 옭 螶 螶 螶跠 﨔 膉 痹 ⋫ 吪 멚 埣 ꯕ 扌 扌 옘 犵 犵 肖 肖 畅 畅 畅 畅 ၥ ၥ ၥ ၥ 帻 똞 똞 똞 颤 䬝 䬝 䬝 ⺁ ⺁ 峁 踷 踷 踷 踷 嗊 嗊 嗊 ⹀ ⹀  遲 䩢 푑팾 뭯 ዇ࣷ䷴ ዇ࣷ䷴ 䬾 갭 魨 魨 魨 㵻 ᣄⲪ ᣄⲪ ᣄⲪ ᣄⲪ 㥨 㥨 몙 큤 큤 큤 ꢡ ꢡ ꢡ 웼 㢓 吋 䂃 䂃 䨠 䕱.

Qu'est-ce qui me manque?

Answer 1

(char)(r.Next(256, 65536)) peut générer des combinaisons de caractères non valides, entraînant un texte illégal, vous ne pouvez donc pas l'utiliser pour créer du contenu de test. Cela peut arriver même si la distribution est valide et qu'un caractère valide est produit. Un exemple est substituts dans U + D800 à U + DFFF, mais il y en a probablement d'autres.

Si vous souhaitez générer un exemple de texte à partir de toutes les plages Unicode, vous devez être conscient d'Unicode lorsque vous le créez, et ne pas simplement convertir aléatoire en char. (Je pense que vous frappez sur quand vous avez dit dans la question que cela a fonctionné lorsque vous avez fourni une gamme plus étroite pour le nombre aléatoire.)

Answer 2

Utilisez byte et non char.

Vos méthodes Compress/Decompress doivent prendre un tableau byte[], et quel que soit leur appel, lisez vos données Unicode et traduisez-les avant de les appeler.

Vous savez que .NET 2.0 contient la classe GZipStream?

Answer 3

quelques expériences:

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

Ceci est sans compression. Ça fonctionne bien.

je vous suggère de changer votre test à ceci:

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); 
} 

Ce teste exactement un caractère à la fois, vous n'avez pas des valeurs aléatoires (pas de problème « parfois usine ») et vous voir s'il y a un certain type de caractères qui ne fonctionne pas.

Answer 4

J'ai le même test pour le cryptage/décryptage.

En utilisant dichotomie, j'ai trouvé que toute chaîne contenant « points de code Surrogates » qui est des caractères Unicode dans la gamme U + 55296 à U + 57343 échouera en utilisant Assert.AreEqual

de sorte que les gammes les plus larges, vous pouvez utiliser sont:

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

et

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