import java.util.Properties;

import java.util.Properties;

     * Creates empty instance whose items will not be alphabetized.

     * @deprecated Use {@link #EditableProperties(boolean)} for clarity instead.

     */

    @Deprecated

    public EditableProperties() {

        this(/* mentioned in #64174 - documented default */false);

    }

    /**

     * Creates instance from an existing map. No comments will be defined.

     * Any order from the existing map will be retained,

     * and further additions will not be alphabetized.

     * @param map a map from String to String

     */

    public EditableProperties(Map<String,String> map) {

        this(false);

        putAll(map);

    }

    /**

import java.io.FileInputStream;

import java.io.InputStreamReader;

import java.io.Reader;

    // test that modifications changes only necessary parts

    public void testVersionability() throws Exception {

        clearWorkDir();

        EditableProperties ep = loadTestProperties();

        EditableProperties ep2 = ep.cloneProperties();

        ep2.setProperty("key24", "new value of key 24");

        String dest = getWorkDirPath()+File.separatorChar+"mod1.properties";

        saveProperties(ep2, dest);

        int res[] = compare(filenameOfTestProperties(), dest);

        assertEquals("One line modified", 1, res[0]);

        assertEquals("No lines added", 0, res[1]);

        assertEquals("No lines removed", 0, res[2]);

        ep2 = ep.cloneProperties();

        ep2.setProperty("key23", "new value of key23");

        dest = getWorkDirPath()+File.separatorChar+"mod2.properties";

        saveProperties(ep2, dest);

        res = compare(filenameOfTestProperties(), dest);

        assertEquals("Four lines modified", 4, res[0]);

        assertEquals("No lines added", 0, res[1]);

        assertEquals("No lines removed", 0, res[2]);

        ep2 = ep.cloneProperties();

        ep2.put("newkey", "new value");

        dest = getWorkDirPath()+File.separatorChar+"mod3.properties";

        saveProperties(ep2, dest);

        res = compare(filenameOfTestProperties(), dest);

        assertEquals("No lines modified", 0, res[0]);

        assertEquals("One line added", 1, res[1]);

        assertEquals("No lines removed", 0, res[2]);

        ep2 = ep.cloneProperties();

        assertNotNull(ep2.get("key14"));

        ep2.remove("key14");

        assertNull(ep2.get("key14"));

        dest = getWorkDirPath()+File.separatorChar+"mod4.properties";

        saveProperties(ep2, dest);

        res = compare(filenameOfTestProperties(), dest);

        assertEquals("No lines modified", 0, res[0]);

        assertEquals("No lines added", 0, res[1]);

        assertEquals("Two lines removed", 2, res[2]);

        ep2 = ep.cloneProperties();

        ep2.setProperty("key21", new String[]{"first line;", "second line;", "third line"});

        dest = getWorkDirPath()+File.separatorChar+"mod5.properties";

        saveProperties(ep2, dest);

        res = compare(filenameOfTestProperties(), dest);

        assertEquals("Four lines modified", 4, res[0]);

        assertEquals("No lines added", 0, res[1]);

        assertEquals("No lines removed", 0, res[2]);

        ep2.setProperty("key21", "first line;second line;third line");

        String dest2 = getWorkDirPath()+File.separatorChar+"mod6.properties";

        saveProperties(ep2, dest2);

        res = compare(dest, dest2);

        assertEquals("Four lines modified", 4, res[0]);

        assertEquals("No lines added", 0, res[1]);

        assertEquals("No lines removed", 0, res[2]);

    }

    public void testComment() throws Exception {

        clearWorkDir();

        EditableProperties ep = loadTestProperties();

        EditableProperties ep2 = ep.cloneProperties();

        ep2.setComment("key10", new String[]{"# this is new comment for property key 10"}, false);

        String dest = getWorkDirPath()+File.separatorChar+"comment1.properties";

        saveProperties(ep2, dest);

        int res[] = compare(filenameOfTestProperties(), dest);

        assertEquals("No lines modified", 0, res[0]);

        assertEquals("One line added", 1, res[1]);

        assertEquals("No lines removed", 0, res[2]);

        ep2 = ep.cloneProperties();

        ep2.setComment("key1", new String[]{"# new comment", "# new comment second line"}, true);

        dest = getWorkDirPath()+File.separatorChar+"comment2.properties";

        saveProperties(ep2, dest);

        res = compare(filenameOfTestProperties(), dest);

        assertEquals("No lines modified", 0, res[0]);

        assertEquals("Two lines added", 2, res[1]);

        assertEquals("No lines removed", 0, res[2]);

        ep2 = ep.cloneProperties();

        ep2.setComment("key26", new String[]{"# changed comment"}, false);

        dest = getWorkDirPath()+File.separatorChar+"comment3.properties";

        saveProperties(ep2, dest);

        res = compare(filenameOfTestProperties(), dest);

        assertEquals("One line modified", 1, res[0]);

        assertEquals("No lines added", 0, res[1]);

        assertEquals("No lines removed", 0, res[2]);

        ep2 = ep.cloneProperties();

        ep2.setComment("key25", new String[]{"# one line comment"}, false);

        dest = getWorkDirPath()+File.separatorChar+"comment4.properties";

        saveProperties(ep2, dest);

        res = compare(filenameOfTestProperties(), dest);

        assertEquals("Two lines modified", 2, res[0]);

        assertEquals("No lines added", 0, res[1]);

        assertEquals("No lines removed", 0, res[2]);

        ep2 = ep.cloneProperties();

        ep2.setComment("key26", ep2.getComment("key26"), true);

        dest = getWorkDirPath()+File.separatorChar+"comment5.properties";

        saveProperties(ep2, dest);

        res = compare(filenameOfTestProperties(), dest);

        assertEquals("No line modified", 0, res[0]);

        assertEquals("One line added", 1, res[1]);

        assertEquals("No lines removed", 0, res[2]);

    }

    private int[] compare(String f1, String f2) throws Exception {

        Reader r1 = null;

        Reader r2 = null;

        try {

            r1 = new InputStreamReader(new FileInputStream(f1), "ISO-8859-1");

            r2 = new InputStreamReader(new FileInputStream(f2), "ISO-8859-1");

            return AntBasedTestUtil.countTextDiffs(r1, r2);

        } finally {

            if (r1 != null) {

                r1.close();

            }

            if (r2 != null) {

                r2.close();

            }

        }

    }

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.InputStreamReader;

import java.io.OutputStreamWriter;

import java.util.AbstractSet;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.HashMap;

import java.util.Iterator;

import java.util.LinkedList;

import java.util.List;

import java.util.ListIterator;

import java.util.NoSuchElementException;

// XXX: consider adding getInitialComment() and setInitialComment() methods

// (useful e.g. for GeneratedFilesHelper)

    /** List of Item instances as read from the properties file. Order is important.

     * Saving properties will save then in this order. */

    private final LinkedList<Item> items;

     * Creates new instance from an existing one.

     * @param ep an instance of EditableProperties

     */

    private EditableProperties(EditableProperties ep) {

        // #64174: use a simple deep copy for speed

        alphabetize = ep.alphabetize;

        items = new LinkedList<Item>();

        itemIndex = new HashMap<String,Item>(ep.items.size() * 4 / 3 + 1);

        for (Item _i : ep.items) {

            Item i = (Item) _i.clone();

            items.add(i);

            itemIndex.put(i.getKey(), i);

        }

    }

    /**

    // non-key item is block of empty lines/comment not associated with any property

    private void createNonKeyItem(List<String> lines) {

        // First check that previous item is not non-key item.

        if (!items.isEmpty()) {

            Item item = items.getLast();

            if (item.getKey() == null) {

                // it is non-key item:  merge them

                item.addCommentLines(lines);

                lines.clear();

                return;

            }

        }

        // create new non-key item

        Item item = new Item(lines);

        addItem(item, false);

        lines.clear();

    }

    // opposite to non-key item: item with valid property declaration and 

    // perhaps some comment lines

    private void createKeyItem(List<String> lines, int commentLinesCount) {

        Item item = new Item(lines.subList(0, commentLinesCount), lines.subList(commentLinesCount, lines.size()));

        addItem(item, false);

        lines.clear();

    }

    private void addItem(Item item, boolean sort) {

        String key = item.getKey();

        if (sort) {

            assert key != null;

            ListIterator<Item> it = items.listIterator();

            while (it.hasNext()) {

                String k = it.next().getKey();

                if (k != null && k.compareToIgnoreCase(key) > 0) {

                    it.previous();

                    it.add(item);

                    itemIndex.put(key, item);

                    return;

                }

            }

        }

        items.add(item);

        if (key != null) {

            itemIndex.put(key, item);

        }

    }

    // does property declaration continue on next line?

    private boolean isContinue(String line) {

        int index = line.length() - 1;

        int slashCount = 0;

        while (index >= 0 && line.charAt(index) == '\\') {

            slashCount++;

            index--;

        }

        // if line ends with odd number of backslash then property definition 

        // continues on next line

        return (slashCount % 2 != 0);

    }

    // does line start with comment delimiter? (whitespaces are ignored)

    private static boolean isComment(String line) {

        line = trimLeft(line);

        if (line.length() != 0 && commentChars.indexOf(line.charAt(0)) != -1) {

            return true;

        } else {

            return false;

        }

    }

    // is line empty? (whitespaces are ignored)

    private static boolean isEmpty(String line) {

        return trimLeft(line).length() == 0;

    }

    // remove all whitespaces from left

    private static String trimLeft(String line) {

        int start = 0;

        while (start < line.length()) {

            if (whiteSpaceChars.indexOf(line.charAt(start)) == -1) {

                break;

            }

            start++;

        }

        return line.substring(start);

    }

    /**

     * Representation of one item read from properties file. It can be either

     * valid property declaration with associated comment or chunk of empty

     * lines or lines with comment which are not associated with any property.

     */

    private static class Item implements Cloneable {

        /** Lines of comment as read from properties file and as they will be

         * written back to properties file. */

        private List<String> commentLines;

        /** Lines with property name and value declaration as read from 

         * properties file and as they will be written back to properties file. */

        private List<String> keyValueLines;

        /** Property key */

        private String key;

        /** Property value */

        private String value;

        /** Should this property be separated from previous one by at least

         * one empty line. */

        private boolean separate;

        // constructor only for cloning

        private Item() {

        }

        /**

         * Create instance which does not have any key and value - just 

         * some empty or comment lines. This item is READ-ONLY.

         */

        public Item(List<String> commentLines) {

            this.commentLines = new ArrayList<String>(commentLines);

        }

        /**

         * Create instance from the lines of comment and property declaration.

         * Property name and value will be split.

         */

        public Item(List<String> commentLines, List<String> keyValueLines) {

            this.commentLines = new ArrayList<String>(commentLines);

            this.keyValueLines = new ArrayList<String>(keyValueLines);

            parse(keyValueLines);

        }

        /**

         * Create new instance with key and value.

         */

        public Item(String key, String value) {

            this.key = key;

            this.value = value;

        }

        /**

         * Create new instance with key and value.

         */

        public Item(String key, List<String> value) {

            this.key = key;

            setValue(value);

        }

        // backdoor for merging non-key items

        void addCommentLines(List<String> lines) {

            assert key == null;

            commentLines.addAll(lines);

        }

        public String[] getComment() {

            String[] res = new String[commentLines.size()];

            for (int i = 0; i < res.length; i++) {

                // #60249: the comment might have Unicode chars in escapes.

                res[i] = decodeUnicode(commentLines.get(i));

            }

            return res;

        }

        public void setComment(String[] commentLines, boolean separate) {

            this.separate = separate;

            this.commentLines = new ArrayList<String>(commentLines.length);

            for (int i = 0; i < commentLines.length; i++) {

                // #60249 again - write only ISO-8859-1.

                this.commentLines.add(encodeUnicode(commentLines[i]));

            }

        }

        public String getKey() {

            return key;

        }

        public String getValue() {

            return value;

        }

        public void setValue(String value) {

            this.value = value;

            keyValueLines = null;

        }

        public void setValue(List<String> value) {

            StringBuffer val = new StringBuffer();

            List<String> l = new ArrayList<String>();

            if (!value.isEmpty()) {

                l.add(encode(key, true) + "=\\"); // NOI18N

                Iterator<String> it = value.iterator();

                while (it.hasNext()) {

                    String s = it.next();

                    val.append(s);

                    s = encode(s, false);

                    l.add(it.hasNext() ? INDENT + s + '\\' : INDENT + s); // NOI18N

                }

            } else {

                // #45061: for no vals, use just "prop="

                l.add(encode(key, true) + '='); // NOI18N

            }

            this.value = val.toString();

            keyValueLines = l;

        }

        public boolean isSeparate() {

            return separate;

        }

        /**

         * Returns persistent image of this property.

         */

        public List<String> getRawData() {

            List<String> l = new ArrayList<String>();

            if (commentLines != null) {

                l.addAll(commentLines);

            }

            if (keyValueLines == null) {

                keyValueLines = new ArrayList<String>();

                if (key != null && value != null) {

                    keyValueLines.add(encode(key, true)+"="+encode(value, false));

                }

            }

            l.addAll(keyValueLines);

            return l;

        }

        private void parse(List<String> keyValueLines) {

            // merge lines into one:

            String line = mergeLines(keyValueLines);

            // split key and value

            splitKeyValue(line);

        }

        private String mergeLines(List<String> lines) {

            String line = ""; // XXX use StringBuilder instead

            Iterator<String> it = lines.iterator();

            while (it.hasNext()) {

                String l = trimLeft(it.next());

                // if this is not the last line then remove last backslash

                if (it.hasNext()) {

                    assert l.endsWith("\\") : lines;

                    l = l.substring(0, l.length()-1);

                }

                line += l;

            }

            return line;

        }

        private void splitKeyValue(String line) {

            int separatorIndex = 0;

            while (separatorIndex < line.length()) {

                char ch = line.charAt(separatorIndex);

                if (ch == '\\') {

                    // ignore next one character

                    separatorIndex++;

                } else {

                    if (keyValueSeparators.indexOf(ch) != -1) {

                        break;

                    }

                }

                separatorIndex++;

            }

            key = decode(line.substring(0, separatorIndex));

            line = trimLeft(line.substring(separatorIndex));

            if (line.length() == 0) {

                value = "";

                return;

            }

            if (strictKeyValueSeparators.indexOf(line.charAt(0)) != -1) {

                line = trimLeft(line.substring(1));

            }

            value = decode(line);

        }

        private static String decode(String input) {

            char ch;

            int len = input.length();

            StringBuffer output = new StringBuffer(len);

            for (int x=0; x<len; x++) {

                ch = input.charAt(x);

                if (ch != '\\') {

                    output.append(ch);

                    continue;

                }

                x++;

                if (x==len) {

                    // backslash at the end? syntax error: ignore it

                    continue;

                }

                ch = input.charAt(x);

                if (ch == 'u') {

                    if (x+5>len) {

                        // unicode character not finished? syntax error: ignore

                        output.append(input.substring(x-1));

                        x += 4;

                        continue;

                    }

                    String val = input.substring(x+1, x+5);

                    try {

                        output.append((char)Integer.parseInt(val, 16));

                    } catch (NumberFormatException e) {

                        // #46234: handle gracefully

                        output.append(input.substring(x - 1, x + 5));

                    }

                    x += 4;

                } else {

                    if (ch == 't') ch = '\t';

                    else if (ch == 'r') ch = '\r';

                    else if (ch == 'n') ch = '\n';

                    else if (ch == 'f') ch = '\f';

                    output.append(ch);

                }

            }

            return output.toString();

        }

        private static String encode(String input, boolean escapeSpace) {

            int len = input.length();

            StringBuffer output = new StringBuffer(len*2);

            for(int x=0; x<len; x++) {

                char ch = input.charAt(x);

                switch(ch) {

                    case ' ':

                        if (x == 0 || escapeSpace)  {

                            output.append('\\');

                        }

                        output.append(' ');

                        break;

                    case '\\':

                        output.append("\\\\");

                        break;

                    case '\t':

                        output.append("\\t");

                        break;

                    case '\n':

                        output.append("\\n");

                        break;

                    case '\r':

                        output.append("\\r");

                        break;

                    case '\f':

                        output.append("\\f");

                        break;

                    default:

                        if ((ch < 0x0020) || (ch > 0x007e)) {

                            output.append("\\u");

                            String hex = Integer.toHexString(ch);

                            for (int i = 0; i < 4 - hex.length(); i++) {

                                output.append('0');

                            }

                            output.append(hex);

                        } else {

                            output.append(ch);

                        }

                }

            }

            return output.toString();

        }

        private static String decodeUnicode(String input) {

            char ch;

            int len = input.length();

            StringBuffer output = new StringBuffer(len);

            for (int x = 0; x < len; x++) {

                ch = input.charAt(x);

                if (ch != '\\') {

                    output.append(ch);

                    continue;

                }

                x++;

                if (x==len) {

                    // backslash at the end? syntax error: ignore it

                    continue;

                }

                ch = input.charAt(x);

                if (ch == 'u') {

                    if (x+5>len) {

                        // unicode character not finished? syntax error: ignore

                        output.append(input.substring(x-1));

                        x += 4;

                        continue;

                    }

                    String val = input.substring(x+1, x+5);

                    try {

                        output.append((char)Integer.parseInt(val, 16));

                    } catch (NumberFormatException e) {

                        // #46234: handle gracefully

                        output.append(input.substring(x - 1, x + 5));

                    }

                    x += 4;

                } else {

                    output.append(ch);

                }

            }

            return output.toString();

        }

        private static String encodeUnicode(String input) {

            int len = input.length();

            StringBuffer output = new StringBuffer(len * 2);

            for (int x = 0; x < len; x++) {

                char ch = input.charAt(x);

                if ((ch < 0x0020) || (ch > 0x007e)) {

                    output.append("\\u"); // NOI18N

                    String hex = Integer.toHexString(ch);

                    for (int i = 0; i < 4 - hex.length(); i++) {

                        output.append('0');

                    }

                    output.append(hex);

                } else {

                    output.append(ch);

                }

            }

            return output.toString();

        }

        @Override

        public Object clone() {

            Item item = new Item();

            if (keyValueLines != null) {

                item.keyValueLines = new ArrayList<String>(keyValueLines);

            }

            if (commentLines != null) {

                item.commentLines = new ArrayList<String>(commentLines);

            }

            item.key = key;

            item.value = value;

            item.separate = separate;

            return item;

        }

    }

    private static class SetImpl extends AbstractSet<Map.Entry<String,String>> {

        private EditableProperties props;

        public SetImpl(EditableProperties props) {

            this.props = props;

        }

        public Iterator<Map.Entry<String,String>> iterator() {

            return new IteratorImpl(props);

        }

        public int size() {

            return props.items.size();

        }

    }

    private static class IteratorImpl implements Iterator<Map.Entry<String,String>> {

        private final EditableProperties props;

        private ListIterator<Item> delegate;

        public IteratorImpl(EditableProperties props) {

            this.props = props;

            delegate = props.items.listIterator();

        }

        public boolean hasNext() {

            return findNext() != null;

        }

        public Map.Entry<String,String> next() {

            Item item = findNext();

            if (item == null) {

                throw new NoSuchElementException();

            }

            delegate.next();

            return new MapEntryImpl(item);

        }

        public void remove() {

            delegate.previous();

            Item item = findNext();

            if (item == null) {

                throw new IllegalStateException();

            }

            int index = delegate.nextIndex();

            props.items.remove(item);

            props.itemIndex.remove(item.getKey());

            delegate = props.items.listIterator(index);

        }

        private Item findNext() {

            while (delegate.hasNext()) {

                Item item = delegate.next();

                if (item.getKey() != null && item.getValue() != null) {

                    // Found one. Back up!

                    delegate.previous();

                    return item;

                }

            }

            return null;

        }

    }

    private static class MapEntryImpl implements Map.Entry<String,String> {

        private Item item;

        public MapEntryImpl(Item item) {

            this.item = item;

        }

        public String getKey() {

            return item.getKey();

        }

        public String getValue() {

            return item.getValue();

        }

        public String setValue(String value) {

            String result = item.getValue();

            item.setValue(value);

            return result;

        }

    }

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.util.Arrays;

import java.util.Collections;

import java.util.HashMap;

import java.util.Iterator;

import java.util.Map;

    public void testLoad() throws Exception {

        Map<String,String> content = new HashMap<String,String>();

        for (int i=1; i<=26; i++) {

            content.put("key"+i, "value"+i);

        }

        content.put("@!#$%^keyA", "valueA!@#$%^&*(){}");

        content.put(" =:keyB", "valueB =:");

        content.put(""+(char)0x1234+"keyC", "valueC"+(char)0x9876);

        content.put("keyD", "");

        content.put("keyE", "");

        content.put("keyF", "");

        content.put("keyG", "");

        content.put("keyH", "value#this is not comment");

        content.put("keyI", "incorrect end: \\u123");

        // #46234: does not handle bad Unicode escapes well

        content.put("keyJ", "malformed Unicode escape: \\uabyz");

        EditableProperties ep = loadTestProperties();

        for (Map.Entry<String,String> entry : content.entrySet()) {

            String key = entry.getKey();

            String value = entry.getValue();

            String epValue = ep.getProperty(key);

            assertEquals("Expected value for key "+key+" is different", value, epValue);

        }

        int count = 0;

        for (Map.Entry<String,String> entry : ep.entrySet()) {

            if (entry.getKey() != null) {

                count++;

            }

        }

        assertEquals("Number of items in property file", content.keySet().size(), count);

    }

    /* Doesn't work; java.util.Properties throws IAE for malformed Unicode escapes:

    public void testJavaUtilPropertiesEquivalence() throws Exception {

        Properties p = loadTestJavaUtilProperties();

        EditableProperties ep = loadTestProperties();

        Iterator it = p.entrySet().iterator();

        while (it.hasNext()) {

            Map.Entry entry = (Map.Entry) it.next();

            String key = (String) entry.getKey();

            String val = (String) entry.getValue();

            assertEquals("right value for " + key, val, ep.getProperty(key));

        }

        assertEquals("right number of items", p.size(), ep.size());

    }

     */

    public void testSave() throws Exception {

        clearWorkDir();

        EditableProperties ep = loadTestProperties();

        String dest = getWorkDirPath()+File.separatorChar+"new.properties";

        saveProperties(ep, dest);

        assertFile("Saved properties must be the same as original one", filenameOfTestProperties(), dest, (String)null);

    }

    public void testClonability() throws Exception {

        clearWorkDir();

        EditableProperties ep = loadTestProperties();

        EditableProperties ep2 = ep.cloneProperties();

        String dest = getWorkDirPath()+File.separatorChar+"new2.properties";

        saveProperties(ep2, dest);

        assertFile("Saved cloned properties must be the same as original one", filenameOfTestProperties(), dest, (String)null);

        EditableProperties ep3 = (EditableProperties)ep.clone();

        dest = getWorkDirPath()+File.separatorChar+"new3.properties";

        saveProperties(ep3, dest);

        assertFile("Saved cloned properties must be the same as original one", filenameOfTestProperties(), dest, (String)null);

    }

    // test that array values are stored correctly

    public void testArrayValues() throws Exception {

        EditableProperties ep = new EditableProperties(false);

        ep.setProperty("key1", new String[]{"1. line;", "2. line;", "3. line"});

        ep.setProperty("key2", "1. line;2. line;3. line");

        String output = getAsString(ep);

        String expected = 

            "key1=\\"+System.getProperty("line.separator")+

            "    1. line;\\"+System.getProperty("line.separator")+

            "    2. line;\\"+System.getProperty("line.separator")+

            "    3. line"+System.getProperty("line.separator")+

            "key2=1. line;2. line;3. line"+System.getProperty("line.separator");

        assertEquals(expected, output);

        assertEquals(ep.getProperty("key1"), "1. line;2. line;3. line");

        assertEquals(ep.getProperty("key2"), "1. line;2. line;3. line");

        ep.setProperty("key1", "one; two; three");

        output = getAsString(ep);

        expected = 

            "key1=one; two; three"+System.getProperty("line.separator")+

            "key2=1. line;2. line;3. line"+System.getProperty("line.separator");

        assertEquals(expected, output);

        assertEquals(ep.getProperty("key1"), "one; two; three");

        assertEquals(ep.getProperty("key2"), "1. line;2. line;3. line");

        ep.setProperty("key2", new String[]{"1. line;", "2. line;", "3. line", "one;", "more;", "line;"});

        ep.setProperty("key", new String[0]);

        output = getAsString(ep);

        expected = 

            "key1=one; two; three"+System.getProperty("line.separator")+

            "key2=\\"+System.getProperty("line.separator")+

            "    1. line;\\"+System.getProperty("line.separator")+

            "    2. line;\\"+System.getProperty("line.separator")+

            "    3. line\\"+System.getProperty("line.separator")+

            "    one;\\"+System.getProperty("line.separator")+

            "    more;\\"+System.getProperty("line.separator")+

            "    line;"+System.getProperty("line.separator")+

            "key="+System.getProperty("line.separator"); // #45061

        assertEquals(expected, output);

        assertEquals(ep.getProperty("key1"), "one; two; three");

        assertEquals(ep.getProperty("key2"), "1. line;2. line;3. lineone;more;line;");

        assertEquals(ep.getProperty("key"), "");

    }

    public void testSorting() throws Exception {

        EditableProperties ep = new EditableProperties(false);

        ep.setProperty("a", "val-a");

        ep.setProperty("c", "val-c");

        ep.put("b", "val-b");

        String output = getAsString(ep);

        String expected = "a=val-a"+System.getProperty("line.separator")+"c=val-c"+

                System.getProperty("line.separator")+"b=val-b"+

                System.getProperty("line.separator");

        assertEquals(expected, output);

        ep = new EditableProperties(false);

        ep.setProperty("a", "val-a");

        ep.setProperty("c", "val-c");

        ep.put("b", "val-b");

        output = getAsString(ep);

        expected = "a=val-a"+System.getProperty("line.separator")+"c=val-c"+

                System.getProperty("line.separator")+"b=val-b"+

                System.getProperty("line.separator");

        assertEquals(expected, output);

        ep = new EditableProperties(true);

        ep.setProperty("a", "val-a");

        ep.setProperty("c", "val-c");

        ep.put("b", "val-b");

        output = getAsString(ep);

        expected = "a=val-a"+System.getProperty("line.separator")+"b=val-b"+

                System.getProperty("line.separator")+"c=val-c"+

                System.getProperty("line.separator");

        assertEquals(expected, output);

    }

    // test that misc chars are correctly escaped, unicode encoded, etc.

    public void testEscaping() throws Exception {

        String umlaut = "" + (char)252;

        EditableProperties ep = new EditableProperties(false);

        ep.setProperty("a a", "a space a");

        ep.setProperty("b"+(char)0x4567, "val"+(char)0x1234);

        ep.setProperty("@!#$%^\\", "!@#$%^&*(){}\\");

        ep.setProperty("d\nd", "d\nnewline\nd");

        ep.setProperty("umlaut", umlaut);

        ep.setProperty("_a a", new String[]{"a space a"});

        ep.setProperty("_b"+(char)0x4567, new String[]{"val"+(char)0x1234});

        ep.setProperty("_@!#$%^\\", new String[]{"!@#$%^&*\\", "(){}\\"});

        ep.setProperty("_d\nd", new String[]{"d\nnew","line\nd", "\n", "end"});

        ep.setProperty("_umlaut", new String[]{umlaut, umlaut});

        String output = getAsString(ep);

        String expected = "a\\ a=a space a"+System.getProperty("line.separator")+

                "b\\u4567=val\\u1234"+System.getProperty("line.separator")+

                "@!#$%^\\\\=!@#$%^&*(){}\\\\"+System.getProperty("line.separator")+

                "d\\nd=d\\nnewline\\nd"+System.getProperty("line.separator")+

                "umlaut=\\u00fc"+System.getProperty("line.separator")+

                "_a\\ a=\\"+System.getProperty("line.separator")+"    a space a"+System.getProperty("line.separator")+

                "_b\\u4567=\\"+System.getProperty("line.separator")+"    val\\u1234"+System.getProperty("line.separator")+

                "_@!#$%^\\\\=\\"+System.getProperty("line.separator")+"    !@#$%^&*\\\\\\"+System.getProperty("line.separator")+

                    "    (){}\\\\"+System.getProperty("line.separator")+

                "_d\\nd=\\"+System.getProperty("line.separator")+"    d\\nnew\\"+System.getProperty("line.separator")+

                    "    line\\nd\\"+System.getProperty("line.separator")+

                    "    \\n\\"+System.getProperty("line.separator")+

                    "    end"+System.getProperty("line.separator")+

                "_umlaut=\\" +System.getProperty("line.separator")+"    \\u00fc\\"+System.getProperty("line.separator")+

                    "    \\u00fc"+System.getProperty("line.separator");

        assertEquals(expected, output);

        assertEquals("a space a", ep.getProperty("a a"));

        assertEquals("val"+(char)0x1234, ep.getProperty("b"+(char)0x4567));

        assertEquals("!@#$%^&*(){}\\", ep.getProperty("@!#$%^\\"));

        assertEquals("d\nnewline\nd", ep.getProperty("d\nd"));

        assertEquals(umlaut, ep.getProperty("umlaut"));

        assertEquals("a space a", ep.getProperty("_a a"));

        assertEquals("val"+(char)0x1234, ep.getProperty("_b"+(char)0x4567));

        assertEquals("!@#$%^&*\\(){}\\", ep.getProperty("_@!#$%^\\"));

        assertEquals("d\nnewline\nd\nend", ep.getProperty("_d\nd"));

        assertEquals(umlaut+umlaut, ep.getProperty("_umlaut"));

    }

    // test that iterator implementation is OK

    public void testIterator() throws Exception {

        EditableProperties ep = loadTestProperties();

        Iterator<Map.Entry<String,String>> it1 = ep.entrySet().iterator();

        while (it1.hasNext()) {

            it1.next();

        }

        Iterator<String> it2 = ep.keySet().iterator();

        while (it2.hasNext()) {

            it2.next();

        }

        it2 = ep.keySet().iterator();

        while (it2.hasNext()) {

            it2.next();

            it2.remove();

        }

        ep.put("a", "aval");

        ep.remove("a");

        ep = loadTestProperties();

        it1 = ep.entrySet().iterator();

        while (it1.hasNext()) {

            Map.Entry<String,String> entry = it1.next();

            assertNotNull("Property key cannot be null", entry.getKey());

            assertNotNull("Property value cannot be null", entry.getValue());

            entry.setValue(entry.getValue()+"-something-new");

        }

        it1 = ep.entrySet().iterator();

        while (it1.hasNext()) {

            it1.next();

            it1.remove();

        }

    }

    // test that syntax errors are survived

    public void testInvalidPropertiesFile() throws Exception {

        String invalidProperty = "key=value without correct end\\";

        ByteArrayInputStream is = new ByteArrayInputStream(invalidProperty.getBytes());

        EditableProperties ep = new EditableProperties(false);

        ep.load(is);

        assertEquals("Syntax error should be resolved", 1, ep.keySet().size());

        assertEquals("value without correct end", ep.getProperty("key"));

    }

    public void testNonLatinComments() throws Exception {

        // #60249.

        String lsep = System.getProperty("line.separator");

        EditableProperties p = new EditableProperties(false);

        p.setProperty("k", "v");

        p.setComment("k", new String[] {"# \u0158ekni koment teda!"}, false);

        String expected = "# \\u0158ekni koment teda!" + lsep + "k=v" + lsep;

        assertEquals("Storing non-Latin chars in comments works", expected, getAsString(p));

        p = new EditableProperties(false);

        p.load(new ByteArrayInputStream(expected.getBytes("ISO-8859-1")));

        assertEquals("Reading non-Latin chars in comments works", Collections.singletonList("# \u0158ekni koment teda!"), Arrays.asList(p.getComment("k")));

        p.setProperty("k", "v2");

        expected = "# \\u0158ekni koment teda!" + lsep + "k=v2" + lsep;

        assertEquals("Reading and re-writing non-Latin chars in comments works", expected, getAsString(p));

    }

    /*

    private Properties loadTestJavaUtilProperties() throws IOException {

        URL u = EditablePropertiesTest.class.getResource("data/test.properties");

        Properties p = new Properties();

        InputStream is = u.openStream();

        try {

            p.load(is);

        } finally {

            is.close();

        }

        return p;

    }

     */

    private String getAsString(EditableProperties ep) throws Exception {

        ByteArrayOutputStream os = new ByteArrayOutputStream();

        ep.store(os);

        os.close();

        return os.toString("ISO-8859-1");

    }