xml单元的局限性 [英] limitations of xml unit
问题描述
我正在尝试比较两个XML文件，它们与XMLUnit相似(为了测试，我只是使用randomize-tool更改了元素顺序).
I’m trying to compare 2 XML files, which are similar (for testing I just changed the element order with a randomize-tool ) with XMLUnit.
元素的最大数量或元素和子元素的最大复杂度是否有限制?
Are there any limitations of the max number of elements or the max complexity of elements and child elements?
只要我的XML文件不太长且元素非常简单，一切就可以正常工作.
As long as my XML file is not too long and the elements are pretty straightforward everything works fine.
但是，一旦元素太复杂(最多五个子元素)，相似的返回false，并且我得到不存在的差异.
But as soon as there are too complex elements (up to five subelements) similar returns false and I get diffs which don’t exist.
我的第一印象是，如果我得到太多简单元素，也会发生相同的结果.但是现在还不能肯定.
My first impression is, that the same result happens if I get too much simple elements. But that’s nor for sure right now.
有人知道XML单元的默认限制吗，是否有可能根据我的经验进行调整?
Does anybody know something about default limitations of XML Unit and is there a possibility to adjust them for my experiences?
也许我应该提到，我必须忽略复杂元素中的某些元素.我不确定这是否重要.它不包含在不太复杂的元素中.
Perhaps I should mention, that I have to ignore certain Element within the complex elements. I’m not sure if that matters. It doesn’t in the less complex elements.
package newXMLComperator;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import org.custommonkey.xmlunit.DetailedDiff;
import org.custommonkey.xmlunit.Diff;
import org.custommonkey.xmlunit.Difference;
import org.custommonkey.xmlunit.XMLUnit;
import org.custommonkey.xmlunit.examples.RecursiveElementNameAndTextQualifier;
public class Arbeiter {
private File quelle, vergleich;
public Arbeiter(File quelle, File vergleich) {
this.quelle=quelle;
this.vergleich=vergleich;
}
public void vergleichen()
{
long tbevore = System.currentTimeMillis();
XMLUnit.setIgnoreAttributeOrder(Boolean.TRUE);
XMLUnit.setIgnoreWhitespace(Boolean.TRUE);
String f1 = lesen(quelle);
String f2 = lesen(vergleich);
try {
Diff diff = new Diff(f1, f2);
diff.overrideElementQualifier(new RecursiveElementNameAndTextQualifier());
diff.overrideDifferenceListener(new IgnoreNamedElementsDifferenceListener(findSVSW_ID(quelle)));
DetailedDiff dd = new DetailedDiff(diff);
boolean result = dd.similar();
StringBuilder sb = new StringBuilder();
if (result ==true)
{
sb.append("Die Dateien sind inhaltsgleich");
}
else
{
sb.append("Die Dateien unterscheiden sich \n \n");
List<Difference>list = dd.getAllDifferences();
for (Difference aktuell : list)
{
if (!aktuell.isRecoverable())
{
sb.append("Der Ausdruck "+aktuell.getControlNodeDetail().getValue()+" wurde gesucht \n");
sb.append("Der Ausdruck "+aktuell.getTestNodeDetail().getValue()+" wurde gefunden \n");
sb.append("Xpath: "+aktuell.getTestNodeDetail().getXpathLocation()+"\n \n");
}
}
}
long tafter = System.currentTimeMillis();
String dauer = Long.toString((tafter-tbevore)/1000);
sb.append("Die Bearbeitung dauerte " +dauer+" Sekunden \n");
speichern(sb.toString());
}
catch (Exception e)
{
e.printStackTrace();
}
}
private String lesen(File datei)
{
String result ="";
try {
BufferedReader leser = new BufferedReader(new FileReader(datei));
StringBuilder sb = new StringBuilder();
String gelesen = leser.readLine();
while (gelesen!=null)
{
sb.append(gelesen);
gelesen=leser.readLine();
}
result=sb.toString();
leser.close();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return result;
}
private List<String> findSVSW_ID(File datei)
{
List<String>liste = new ArrayList<String>();
liste.add("AUFTRAGSCHLUESSEL");
liste.add("LIEFERUNGSCHLUESSEL");
try {
BufferedReader leser = new BufferedReader(new FileReader(datei));
String gelesen = leser.readLine();
while (gelesen!=null)
{
if (gelesen.contains("SVSW_ID"))
{
String [] teile = gelesen.split(">");
String temp = teile[0].replaceAll("<", "");
if (!liste.contains(temp))
{
String t2=temp.replaceAll(" ", "");
liste.add(t2);
}
}
gelesen=leser.readLine();
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return liste;
}
private void speichern(String text)
{
File datei = new File(quelle.getParent()+"/ausgabe.txt");
try {
BufferedWriter schreiber = new BufferedWriter(new FileWriter(datei));
schreiber.write(text);
schreiber.flush();
schreiber.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
感谢帮助
推荐答案
感谢快速支持.我将进一步尝试.
Thanks for the quick support. I will give it a further try.
阅读3.4.4之后.的 http://xmlunit.sourceforge.net/userguide/html/ar01s03.html 我认为RecursiveElementNameAndTextQuaifier是正确的，因为我的子节点的顺序在测试节点和控制节点之间是不同的.
After reading 3.4.4. of http://xmlunit.sourceforge.net/userguide/html/ar01s03.html I think, that the RecursiveElementNameAndTextQuaifier is the correct one, because the order of my child nodes differs between test and control node.
我的理解正确吗，只有RecursiveElementNameAndTextQuaifier可以满足我的要求，而不必考虑子节点中的级别数?
Is my understanding correct, that only the RecursiveElementNameAndTextQuaifier can accomplish my requirements without subjection to the number of levels in my child nodes?
内存使用情况似乎还可以.在应用.similar()方法时，Java VM使用大约3 GB的空间.这根本不是问题.
The memory usage seems to be ok. While applying the .similar() method the java VM uses round about 3 GB. That shouldn’t be a problem at all.
再次感谢
这篇关于xml单元的局限性的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
