Attachment #93024 for bug #177192

This Bugzilla instance is a read-only archive of historic NetBeans bug reports. To report a bug in NetBeans please follow the project's instructions for reporting issues.

View | Details | Raw Unified | Return to bug 177192
Collapse All | Expand All

Lines 80-85 Link Here

(-)a/xml.text/src/org/netbeans/modules/xml/text/folding/TokenElement.java (+1 lines)
80	return indentLevel;	80	return indentLevel;
81	}	81	}
82		82
		83	@Override
83	public String toString() {	84	public String toString() {
84	return type + ", " + name + ", " + startOffset + ", " + endOffset;	85	return type + ", " + name + ", " + startOffset + ", " + endOffset;
85	}	86	}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 1997-2010 Sun Microsystems, Inc. All rights reserved.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common


import java.io.IOException;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Stack;
import javax.swing.text.AbstractDocument;

import org.netbeans.api.lexer.TokenSequence;
import org.netbeans.api.xml.lexer.XMLTokenId;
import org.netbeans.editor.BaseDocument;
import org.netbeans.editor.Formatter;
import org.netbeans.editor.Utilities;
import org.netbeans.modules.editor.indent.api.IndentUtils;
import org.netbeans.modules.editor.indent.spi.Context;

import org.netbeans.modules.editor.structure.formatting.TagBasedLexerFormatter;
import org.netbeans.modules.xml.text.folding.TokenElement;
import org.netbeans.modules.xml.text.folding.TokenElement.TokenType;
import org.netbeans.modules.xml.text.syntax.XMLKit;

/**
 * New XML formatter based on Lexer APIs.


    private static final String TAG_OPENING_PREFIX = "<"; //NOI18N
    private static final String TAG_CLOSING_PREFIX = "</"; //NOI18N

    private final LanguagePath languagePath;
    private int spacesPerTab = 4;


            jts.moveNext();
            Token token = jts.token();

            if (token.id() == XMLTokenId.TAG
                    && !token.text().toString().endsWith("/>")) { //NOI18N

                while (jts.movePrevious()) {
                    int tokenOffset = jts.offset();

    }

// # 170343
    @Override
    public void reformat(Context context, final int startOffset, final int endOffset)
            throws BadLocationException {
        final BaseDocument doc = (BaseDocument) context.document();
        doc.render(new Runnable() {

            public void run() {
                doReformat(doc, startOffset, endOffset);
            }
        });
    }

    public BaseDocument doReformat(BaseDocument doc, int startOffset, int endOffset) {
        spacesPerTab = IndentUtils.indentLevelSize(doc);
        try {
            List<TokenIndent> tags = getTags(doc, startOffset, endOffset);
            for (int i = tags.size() - 1; i >= 0; i--) {
                if (tags.get(i).isPreserveIndent()) {
                    continue;
                }
                TokenElement tag = tags.get(i).getToken();

                int so = tag.getStartOffset();
                int lineOffset = Utilities.getLineOffset(doc, so);

                String tagName = tag.getName();
                if (tagName.startsWith("</")) {
                    /* For Eg:-

                    int ndx = lineStr.lastIndexOf(tagName);
                    if (ndx != -1) {
                        lineStr = lineStr.substring(0, ndx);
                        int ndx2 = lineStr.lastIndexOf("<" + tagName.substring(2));
                        if (ndx2 == -1) {//no start found in this line, so indent this tag
                            changePrettyText(doc, tag, so);
                        } else {

                } else {
                    changePrettyText(doc, tag, so);
                }
            }
        } catch (BadLocationException ble) {
            //ignore exception
        } catch (IOException iox) {
            //ignore exception
        } finally {
            //((AbstractDocument)doc).readUnlock();
        }
        return doc;
    }

    private void changePrettyText(BaseDocument doc, TokenElement tag, int so) throws BadLocationException {
        Formatter formatter = Formatter.getFormatter(XMLKit.class);
        formatter.setExpandTabs(false);
        //i expected the call IndentUtils.createIndentString() to return
        //the correct string for the indent level, but it doesn't.
        //so this is just a workaround.
        String newIndentText = IndentUtils.createIndentString(doc,
                tag.getIndentLevel() * spacesPerTab);
        //String newIndentText = formatter.getIndentString(doc, tag.getIndentLevel());
        int previousEndOffset = Utilities.getFirstNonWhiteBwd(doc, so) + 1;
        String temp = doc.getText(previousEndOffset, so - previousEndOffset);
        if (temp.indexOf("\n") != -1) {
            int i = Utilities.getRowFirstNonWhite(doc, so);
            int rowStart = Utilities.getRowStart(doc, so);
            doc.insertString(so, newIndentText, null);
            doc.remove(rowStart, i - rowStart);
        } else {
            doc.insertString(so, "\n" + newIndentText, null);
             doc.insertString(so, "\n" + newIndentText, null);
        }
    }


     * This method parses the document using lexer and creates folds and adds
     * them to the fold hierarchy.
     */
    private List<TokenIndent> getTags(BaseDocument basedoc, int startOffset, int endOffset)
            throws BadLocationException, IOException {
        List<TokenIndent> tags = new ArrayList<TokenIndent>();
        LinkedList<Boolean> preserveNesting_outdent = new LinkedList<Boolean>();
        preserveNesting_outdent.add(Boolean.FALSE);
        boolean preserveWhitespace = false;
        boolean settingSpaceValue = false;
        int indentLevel = -1;
        basedoc.readLock();
        int incrIndentLevelBy = 0;
        try {
            //are we formatting from the beginning of doc or a subsection
            int line = Utilities.getLineOffset(basedoc, startOffset);
            if (line > 0) {
                boolean nested = isSubSectionToFormatNested(basedoc, startOffset);
                //we are formatting a subsection
                int precedingWordLoc = Utilities.getFirstNonWhiteBwd(basedoc, startOffset);
                int previousLine = Utilities.getLineOffset(basedoc, precedingWordLoc);
                int previousLineIndentation = 0;
                //we need to get the previous line and find its indentation

                //has selected the entire line to format
                //the previous line will be the same as current line if user
                //selected a part of line to format
                if (previousLine != line) {
                    previousLineIndentation = Utilities.getRowIndent(basedoc, precedingWordLoc);
                } else {
                    previousLineIndentation = Utilities.getRowIndent(basedoc, startOffset);
                }
                //the section being formatted should be idented wrt to previous line's indentation

                int div = previousLineIndentation / spacesPerTab;
                if (nested) {
                    incrIndentLevelBy = div + 1;
                } else {
                    incrIndentLevelBy = div;
                }

            }
            TokenHierarchy tokenHierarchy = TokenHierarchy.get(basedoc);
            TokenSequence<XMLTokenId> tokenSequence = tokenHierarchy.tokenSequence();
            org.netbeans.api.lexer.Token<XMLTokenId> token = tokenSequence.token();
            // Add the text token, if any, before xml declaration to document node
            if (token != null && token.id() == XMLTokenId.TEXT) {
                if (tokenSequence.moveNext()) {
                    token = tokenSequence.token();

            }
            int currentTokensSize = 0;
            Stack<TokenElement> stack = new Stack<TokenElement>();
            String currentNode = null;
            while (tokenSequence.moveNext()) {
                token = tokenSequence.token();
                XMLTokenId tokenId = token.id();
                String image = token.text().toString();
                if (tokenSequence.offset() > endOffset) {
                    break;
                    continue;
                }
                boolean tokenInSelectionRange = tokenSequence.offset() >= startOffset;
                TokenType tokenType = TokenType.TOKEN_WHITESPACE;
                switch (tokenId) {
                    case TAG: {
                        int len = image.length();
                        if (image.charAt(len - 1) == '>') {// '/>'
                            if (len == 2) {
                                if (!preserveWhitespace) {
                                    --indentLevel;
                                }
                                if (!stack.empty()) {
                                    stack.pop();
                                }

                        } else {
                            tokenType = TokenType.TOKEN_ELEMENT_START_TAG;
                            if (image.startsWith("</")) {
                                String tagName = image.substring(2);
                                currentNode = tagName;
                                int begin = currentTokensSize;
                                int end = begin + image.length();

                                boolean preservingWhitespaceOnClose = preserveNesting_outdent.removeLast();
                                if (indentLevel < 0) {
                                    indentLevel = 0;
                                }
                                
                                TokenElement tag = new TokenElement(tokenType, image, begin, end, indentLevel);
                                if (tokenInSelectionRange) {
                                    tags.add(new TokenIndent(tag, preservingWhitespaceOnClose));
                                }
                                if (!preserveNesting_outdent.getLast()) {
                                    --indentLevel;
                                }
                            } else {
                                String tagName = image.substring(1);
                                int begin = currentTokensSize;
                                int end = begin + image.length();
                                preserveWhitespace = preserveNesting_outdent.getLast();
                                if (!preserveWhitespace) {
                                    ++indentLevel;
                                }
                                preserveNesting_outdent.add(preserveWhitespace);
                                TokenElement tag = new TokenElement(tokenType, tagName, begin, end, indentLevel);
                                if (tokenInSelectionRange) {
                                    tags.add(new TokenIndent(tag, preserveWhitespace));
                                }
                            }
                            settingSpaceValue = false;
                        }
                        break;
                    }

                    case PI_TARGET:
                    case PI_CONTENT:
                    case PI_END:
                    case ARGUMENT: //attribute of an element
                    case VALUE:
                    case TEXT:
                    case CHARACTER:
                    case WS:
                    case OPERATOR:
                    case DECLARATION:
                        break; //Do nothing for above case's
                    case ARGUMENT: //attribute of an element
                        settingSpaceValue = token.text().equals("xml:space");
                        break;
                    case VALUE:
                        if (settingSpaceValue) {
                            if (token.text().equals("\"preserve\"")) {
                                preserveWhitespace = true;
                            } else if (token.text().equals("\"default\"")) {
                                preserveWhitespace = false;
                            }
                            preserveNesting_outdent.set(preserveNesting_outdent.size() - 1, preserveWhitespace);
                            settingSpaceValue = false;
                        }
                        break;

                    case ERROR:
                    case EOL:
                    default:
                        throw new IOException("Invalid token found in document: "
                                + "Please use the text editor to resolve the issues...");
                }
                currentTokensSize += image.length();
            }


    public boolean isOneLiner(int start, int end, BaseDocument doc) {
        try {
            return Utilities.getLineOffset(doc, start)
                    == Utilities.getLineOffset(doc, end);
        } catch (BadLocationException ex) {
            //Exceptions.printStackTrace(ex);
            return false;
        }
    }

    private boolean isSubSectionToFormatNested(BaseDocument baseDoc, int startOffset) {
        AbstractDocument doc = (AbstractDocument) baseDoc;
        doc.readLock();
        try {
            TokenHierarchy th = TokenHierarchy.get(doc);
            TokenSequence ts = th.tokenSequence();
            ts.move(startOffset);
            while (ts.movePrevious()) {
                Token t = ts.token();
                if (t.id() == XMLTokenId.PI_END) {
                    return false;
                }
                String tagText = t.text().toString();
                if (tagText.startsWith("</") || tagText.equals("/>")) {
                    return false;
                }
                if (tagText.startsWith("<")) {
                    return true;
                }
            }
        } catch (Exception ex) {
            //return false anyway
        } finally {
            doc.readUnlock();
        }
        return false;
    }

    private class TokenIndent {

        private TokenElement token;
        private boolean preserveIndent;

        public TokenIndent(TokenElement token, boolean preserveIndent) {
            this.token = token;
            this.preserveIndent = preserveIndent;
        }

        public TokenElement getToken() {
            return token;
        }

        public boolean isPreserveIndent() {
            return preserveIndent;
        }

        public void setPreserveIndent(boolean preserveIndent) {
            this.preserveIndent = preserveIndent;
        }

        @Override
        public String toString() {
            return "TokenIndent: name=" + token.getName() + " preserveIndent=" + preserveIndent;
        }
    }
}

Lines 1-7 Link Here

(-)a/xml.text/test/unit/src/org/netbeans/modules/xml/text/indent/XMLLexerFormatterTest.java (-23 / +60 lines)
1	/*	1	/*
2	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.	2	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
3	*	3	*
4	* Copyright 1997-2009 Sun Microsystems, Inc. All rights reserved.	4	* Copyright 1997-2010 Sun Microsystems, Inc. All rights reserved.
5	*	5	*
6	* The contents of this file are subject to the terms of either the GNU	6	* The contents of this file are subject to the terms of either the GNU
7	* General Public License Version 2 only ("GPL") or the Common	7	* General Public License Version 2 only ("GPL") or the Common
Lines 48-54 Link Here
48	* @author Samaresh (samaresh.panda@sun.com)	48	* @author Samaresh (samaresh.panda@sun.com)
49	*/	49	*/
50	public class XMLLexerFormatterTest extends AbstractTestCase {	50	public class XMLLexerFormatterTest extends AbstractTestCase {
51		51
52	public XMLLexerFormatterTest(String testName) {	52	public XMLLexerFormatterTest(String testName) {
53	super(testName);	53	super(testName);
54	}	54	}
Lines 61-69 Link Here
61	suite.addTest(new XMLLexerFormatterTest("testFormatPerformance"));	61	suite.addTest(new XMLLexerFormatterTest("testFormatPerformance"));
62	suite.addTest(new XMLLexerFormatterTest("testFormatSubsection1"));	62	suite.addTest(new XMLLexerFormatterTest("testFormatSubsection1"));
63	suite.addTest(new XMLLexerFormatterTest("testFormatSubsection2"));	63	suite.addTest(new XMLLexerFormatterTest("testFormatSubsection2"));
		64	suite.addTest(new XMLLexerFormatterTest("testFormat_PreserveWhitespace"));
		65	suite.addTest(new XMLLexerFormatterTest("testFormat_WithNestedPreserveWhitespace"));
		66	suite.addTest(new XMLLexerFormatterTest("testFormatSubsection_PreserveWhitespace"));
64	return suite;	67	return suite;
65	}	68	}
66		69
67	/**	70	/**
68	* Formats an input document and then compares the formatted doc	71	* Formats an input document and then compares the formatted doc
69	* with a document that represents expected outcome.	72	* with a document that represents expected outcome.
Lines 74-93 Link Here
74	XMLLexerFormatter formatter = new XMLLexerFormatter(null);	77	XMLLexerFormatter formatter = new XMLLexerFormatter(null);
75	BaseDocument formattedDoc = formatter.doReformat(inputDoc, 0, inputDoc.getLength());	78	BaseDocument formattedDoc = formatter.doReformat(inputDoc, 0, inputDoc.getLength());
76	System.out.println(formattedDoc.getText(0, formattedDoc.getLength()));	79	System.out.println(formattedDoc.getText(0, formattedDoc.getLength()));
77	BaseDocument outputDoc = getDocument("indent/output.xml");	80	BaseDocument outputDoc = getDocument("indent/output.xml");
78	assert(compare(formattedDoc, outputDoc));	81	assert (compare(formattedDoc, outputDoc));
79	}	82	}
80		83
81	public void testFormatSubsection() throws Exception {	84	public void testFormatSubsection() throws Exception {
82	BaseDocument inputDoc = getDocument("indent/input_sub.xml");	85	BaseDocument inputDoc = getDocument("indent/input_sub.xml");
83	//format a subsection of the inputDoc	86	//format a subsection of the inputDoc
84	XMLLexerFormatter formatter = new XMLLexerFormatter(null);	87	XMLLexerFormatter formatter = new XMLLexerFormatter(null);
85	BaseDocument formattedDoc = formatter.doReformat(inputDoc, 72, 97);	88	BaseDocument formattedDoc = formatter.doReformat(inputDoc, 72, 97);
86	System.out.println(formattedDoc.getText(0, formattedDoc.getLength()));	89	System.out.println(formattedDoc.getText(0, formattedDoc.getLength()));
87	BaseDocument outputDoc = getDocument("indent/output_sub.xml");	90	BaseDocument outputDoc = getDocument("indent/output_sub.xml");
88	assert(compare(formattedDoc, outputDoc));	91	assert (compare(formattedDoc, outputDoc));
89	}	92	}
90		93
91	//for bug 139160	94	//for bug 139160
92	public void testFormatForTab() throws Exception {	95	public void testFormatForTab() throws Exception {
93	BaseDocument inputDoc = getDocument("indent/input2.xsd");	96	BaseDocument inputDoc = getDocument("indent/input2.xsd");
Lines 95-105 Link Here
95	XMLLexerFormatter formatter = new XMLLexerFormatter(null);	98	XMLLexerFormatter formatter = new XMLLexerFormatter(null);
96	BaseDocument formattedDoc = formatter.doReformat(inputDoc, 0, inputDoc.getLength());	99	BaseDocument formattedDoc = formatter.doReformat(inputDoc, 0, inputDoc.getLength());
97	System.out.println(formattedDoc.getText(0, formattedDoc.getLength()));	100	System.out.println(formattedDoc.getText(0, formattedDoc.getLength()));
98	BaseDocument outputDoc = getDocument("indent/output2.xsd");	101	BaseDocument outputDoc = getDocument("indent/output2.xsd");
99	assert(compare(formattedDoc, outputDoc));	102	assert (compare(formattedDoc, outputDoc));
100	}	103	}
101		104
102
103	public void testFormatPerformance() throws Exception {	105	public void testFormatPerformance() throws Exception {
104	BaseDocument inputDoc = getDocument("indent/1998stats.xml");	106	BaseDocument inputDoc = getDocument("indent/1998stats.xml");
105	//format the inputDoc	107	//format the inputDoc
Lines 107-114 Link Here
107	long t1 = System.currentTimeMillis();	109	long t1 = System.currentTimeMillis();
108	formatter.doReformat(inputDoc, 0, inputDoc.getLength());	110	formatter.doReformat(inputDoc, 0, inputDoc.getLength());
109	long t2 = System.currentTimeMillis();	111	long t2 = System.currentTimeMillis();
110	System.out.println("Time taken to format NFL XML in ms:: " + (t2-t1) );	112	System.out.println("Time taken to format NFL XML in ms:: " + (t2 - t1));
111		113
112	//try OTA Schema	114	//try OTA Schema
113	inputDoc = getDocument("indent/1998stats.xml");	115	inputDoc = getDocument("indent/1998stats.xml");
114	//format the inputDoc	116	//format the inputDoc
Lines 116-140 Link Here
116	t1 = System.currentTimeMillis();	118	t1 = System.currentTimeMillis();
117	formatter.doReformat(inputDoc, 0, inputDoc.getLength());	119	formatter.doReformat(inputDoc, 0, inputDoc.getLength());
118	t2 = System.currentTimeMillis();	120	t2 = System.currentTimeMillis();
119	System.out.println("Time taken to format OTA Schema in ms:: " + (t2-t1) );	121	System.out.println("Time taken to format OTA Schema in ms:: " + (t2 - t1));
120	}	122	}
		123
121	public void testFormatSubsection1() throws Exception {	124	public void testFormatSubsection1() throws Exception {
122	BaseDocument inputDoc = getDocument("indent/input_sub1.xml");	125	BaseDocument inputDoc = getDocument("indent/input_sub1.xml");
123	//format a subsection of the inputDoc	126	//format a subsection of the inputDoc
124	XMLLexerFormatter formatter = new XMLLexerFormatter(null);	127	XMLLexerFormatter formatter = new XMLLexerFormatter(null);
125	BaseDocument formattedDoc = formatter.doReformat(inputDoc, 39, 68);	128	BaseDocument formattedDoc = formatter.doReformat(inputDoc, 46, 74);
126	System.out.println(formattedDoc.getText(0, formattedDoc.getLength()));	129	System.out.println(formattedDoc.getText(0, formattedDoc.getLength()));
127	BaseDocument outputDoc = getDocument("indent/output_sub1.xml");	130	BaseDocument outputDoc = getDocument("indent/output_sub1.xml");
128	assert(compare(formattedDoc, outputDoc));	131	assert (compare(formattedDoc, outputDoc));
129	}	132	}
130		133
131	public void testFormatSubsection2() throws Exception {	134	public void testFormatSubsection2() throws Exception {
132	BaseDocument inputDoc = getDocument("indent/input_sub2.xml");	135	BaseDocument inputDoc = getDocument("indent/input_sub2.xml");
133	//format a subsection of the inputDoc	136	//format a subsection of the inputDoc
134	XMLLexerFormatter formatter = new XMLLexerFormatter(null);	137	XMLLexerFormatter formatter = new XMLLexerFormatter(null);
135	BaseDocument formattedDoc = formatter.doReformat(inputDoc, 68, 83);	138	BaseDocument formattedDoc = formatter.doReformat(inputDoc, 51, 80);
136	System.out.println(formattedDoc.getText(0, formattedDoc.getLength()));	139	System.out.println(formattedDoc.getText(0, formattedDoc.getLength()));
137	BaseDocument outputDoc = getDocument("indent/output_sub2.xml");	140	BaseDocument outputDoc = getDocument("indent/output_sub2.xml");
138	assert(compare(formattedDoc, outputDoc));	141	assert (compare(formattedDoc, outputDoc));
		142	}
		143
		144	//for bug 170343
		145	public void testFormat_PreserveWhitespace() throws Exception {
		146	BaseDocument inputDoc = getDocument("indent/input_preserve.xml");
		147	//format the inputDoc
		148	XMLLexerFormatter formatter = new XMLLexerFormatter(null);
		149	BaseDocument formattedDoc = formatter.doReformat(inputDoc, 0, inputDoc.getLength());
		150	System.out.println(formattedDoc.getText(0, formattedDoc.getLength()));
		151	BaseDocument outputDoc = getDocument("indent/output_preserve.xml");
		152	assert (compare(formattedDoc, outputDoc));
		153	}
		154
		155	//for bug 170343
		156	public void testFormat_WithNestedPreserveWhitespace() throws Exception {
		157	BaseDocument inputDoc = getDocument("indent/input_withpreserve.xml");
		158	//format the inputDoc
		159	XMLLexerFormatter formatter = new XMLLexerFormatter(null);
		160	BaseDocument formattedDoc = formatter.doReformat(inputDoc, 0, inputDoc.getLength());
		161	System.out.println(formattedDoc.getText(0, formattedDoc.getLength()));
		162	BaseDocument outputDoc = getDocument("indent/output_withpreserve.xml");
		163	assert (compare(formattedDoc, outputDoc));
		164	}
		165
		166	//for bug 170343
		167	public void testFormatSubsection_PreserveWhitespace() throws Exception {
		168	BaseDocument inputDoc = getDocument("indent/input_preserve.xml");
		169	//format the inputDoc
		170	XMLLexerFormatter formatter = new XMLLexerFormatter(null);
		171	System.out.println("SECTION:" + inputDoc.getText(91, 87));
		172	BaseDocument formattedDoc = formatter.doReformat(inputDoc, 91, 91 + 87);
		173	System.out.println(formattedDoc.getText(0, formattedDoc.getLength()));
		174	BaseDocument outputDoc = getDocument("indent/output_preserve.xml");
		175	assert (compare(formattedDoc, outputDoc));
139	}	176	}
140	}	177	}

Lines 1-31 Link Here

(-)a/xml.text/test/unit/src/org/netbeans/modules/xml/text/indent/input.xml (-23 / +24 lines)
1	<?xml version="1.0" encoding="UTF-8"?>	1	<?xml version="1.0" encoding="UTF-8"?>
2		2
3	<!-- hello world -->	3	<!-- hello world -->
		4	<wrap>
		5	<root>
		6	<a><b>hello world</b></a>
		7	</root>
4		8
5	<root>
6	<a><b>hello world</b></a>
7	</root>
8		9
		10	<!-- bug# 135478 -->
		11	<root>
9		12
10	<!-- bug# 135478 -->	13	<a>
11	<root>
12
13	<a>
14
15	<b>test</b>
16
17
18	</a>
19	</root>
20		14
21	<!-- bug# 135217-->	15	<b>test</b>
22	<root>
23	<a>
24	<b>test</b>
25	</a>
26	</root>
27		16
28	<!-- bug#135107 -->	17
29	<root>	18	</a>
30	<property name="AVERAGE">1</property>	19	</root>
31	</root>	20
		21	<!-- bug# 135217-->
		22	<root>
		23	<a>
		24	<b>test</b>
		25	</a>
		26	</root>
		27
		28	<!-- bug#135107 -->
		29	<root>
		30	<property name="AVERAGE">1</property>
		31	</root>
		32	</wrap>

Lines 1-5 Link Here

(-)a/xml.text/test/unit/src/org/netbeans/modules/xml/text/indent/input_sub1.xml (-2 / +2 lines)
1	<?xml version="1.0" encoding="UTF-8"?>	1	<?xml version="1.0" encoding="UTF-8"?>
		2	<root>
2	<test attr="replace"></test>	3	<test attr="replace"></test>
3	<root>	4	<a/>
4	</root>	5	</root>
5

Lines 1-4 Link Here

(-)a/xml.text/test/unit/src/org/netbeans/modules/xml/text/indent/input_sub2.xml (-1 / +2 lines)
1	<?xml version="1.0" encoding="UTF-8"?>	1	<?xml version="1.0" encoding="UTF-8"?>
2	<root>	2	<root>
		3	<a/>
		4	<test attr="replace"></test>
3	</root>	5	</root>
4	<test attr="replace"></test>

Lines 1-33 Link Here

(-)a/xml.text/test/unit/src/org/netbeans/modules/xml/text/indent/output.xml (-25 / +26 lines)
1	<?xml version="1.0" encoding="UTF-8"?>	1	<?xml version="1.0" encoding="UTF-8"?>
2		2
3	<!-- hello world -->	3	<!-- hello world -->
		4	<wrap>
		5	<root>
		6	<a>
		7	<b>hello world</b>
		8	</a>
		9	</root>
4		10
5	<root>
6	<a>
7	<b>hello world</b>
8	</a>
9	</root>
10		11
		12	<!-- bug# 135478 -->
		13	<root>
11		14
12	<!-- bug# 135478 -->	15	<a>
13	<root>
14
15	<a>
16
17	<b>test</b>
18
19
20	</a>
21	</root>
22		16
23	<!-- bug# 135217-->	17	<b>test</b>
24	<root>
25	<a>
26	<b>test</b>
27	</a>
28	</root>
29		18
30	<!-- bug#135107 -->	19
31	<root>	20	</a>
32	<property name="AVERAGE">1</property>	21	</root>
33	</root>	22
		23	<!-- bug# 135217-->
		24	<root>
		25	<a>
		26	<b>test</b>
		27	</a>
		28	</root>
		29
		30	<!-- bug#135107 -->
		31	<root>
		32	<property name="AVERAGE">1</property>
		33	</root>
		34	</wrap>

Lines 1-5 Link Here

(-)a/xml.text/test/unit/src/org/netbeans/modules/xml/text/indent/output_sub1.xml (-2 / +2 lines)
1	<?xml version="1.0" encoding="UTF-8"?>	1	<?xml version="1.0" encoding="UTF-8"?>
2	<test attr="replace"></test>
3	<root>	2	<root>
		3	<test attr="replace"></test>
		4	<a/>
4	</root>	5	</root>
5

Lines 1-4 Link Here

(-)a/xml.text/test/unit/src/org/netbeans/modules/xml/text/indent/output_sub2.xml (-1 / +2 lines)
1	<?xml version="1.0" encoding="UTF-8"?>	1	<?xml version="1.0" encoding="UTF-8"?>
2	<root>	2	<root>
		3	<a/>
		4	<test attr="replace"></test>
3	</root>	5	</root>
4	<test attr="replace"></test>

Return to bug 177192