5584

pending completion

Build # 5584

Build Type

push

travis-ci

Committed by

dkayiwa

Commit Message

<a href="https://github.com/openmrs/openmrs-core/commit/<a class=hub.com/openmrs/openmrs-core/commit/c3a4609727d336416c4b3840c7f55f47001c8341">c3a460972<a href="https://github.com/openmrs/openmrs-core/commit/c3a4609727d336416c4b3840c7f55f47001c8341">&quot;&gt;Fixing random NPE when running tests - TRUNK-5180
(cherry picked from commit </a><a class="double-link" href="https://github.com/openmrs/openmrs-core/commit/<a class="double-link" href="https://github.com/openmrs/openmrs-core/commit/016896ae448d57225f04b4088305466f72d86170">016896ae4</a>">016896ae4</a><a href="https://github.com/openmrs/openmrs-core/commit/c3a4609727d336416c4b3840c7f55f47001c8341">)

Run Details

2 of 2 new or added lines in 1 file covered. (100.0%)

18287 of 32199 relevant lines covered (56.79%)

0.57 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

44.54

/api/src/main/java/org/openmrs/util/NaturalStrings.java

/*
 * Copyright (c) 2006, Stephen Kelvin Friedrich,  All rights reserved.
 *
 * This a BSD license. If you use or enhance the code, I'd be pleased if you sent a mail to s.friedrich@eekboom.com
 *
 * Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
 * following conditions are met:
 *     * Redistributions of source code must retain the above copyright notice, this list of conditions and the
 *       following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the
         following disclaimer in the documentation and/or other materials provided with the distribution.
 *     * Neither the name of the "Stephen Kelvin Friedrich" nor the names of its contributors may be used to endorse
 *       or promote products derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

package org.openmrs.util;

import java.text.Collator;
import java.util.Comparator;

/**
 * Utility class for natural String comparison operations
 * 
 * @since 1.5
 */
public final class NaturalStrings {
        
        /**
         * <p>
         * A string comparator that does case-sensitive comparisons and handles embedded numbers
         * correctly.
         * </p>
         * <p>
         * <b>Do not use</b> if your app might ever run on any locale that uses more than 7-bit ascii
         * characters.
         * </p>
         */
        private static final Comparator<String> NATURAL_COMPARATOR_ASCII = new Comparator<String>() {
                
                @Override
                public int compare(String o1, String o2) {
                        return compareNaturalAscii(o1, o2);
                }
        };
        
        /**
         * <p>
         * A string comparator that does case insensitive comparisons and handles embedded numbers
         * correctly.
         * </p>
         * <p>
         * <b>Do not use</b> if your app might ever run on any locale that uses more than 7-bit ascii
         * characters.
         * </p>
         */
        private static final Comparator<String> IGNORE_CASE_NATURAL_COMPARATOR_ASCII = new Comparator<String>() {
                
                @Override
                public int compare(String o1, String o2) {
                        return compareNaturalIgnoreCaseAscii(o1, o2);
                }
        };
        
        /**
         * This is a utility class (static methods only), don't instantiate.
         */
        private NaturalStrings() {
        }
        
        /**
         * Returns a comparator that compares contained numbers based on their numeric values and
         * compares other parts using the current locale's order rules.
         * <p>
         * For example in German locale this will be a comparator that handles umlauts correctly and
         * ignores upper/lower case differences.
         * </p>
         * 
         * @return <p>
         *         A string comparator that uses the current locale's order rules and handles embedded
         *         numbers correctly.
         *         </p>
         * @see #getNaturalComparator(java.text.Collator)
         */
        public static Comparator<String> getNaturalComparator() {
                Collator collator = Collator.getInstance();
                return getNaturalComparator(collator);
        }
        
        /**
         * Returns a comparator that compares contained numbers based on their numeric values and
         * compares other parts using the given collator.
         * 
         * @param collator used for locale specific comparison of text (non-number) subwords - must not
         *            be null
         * @return <p>
         *         A string comparator that uses the given Collator to compare subwords and handles
         *         embedded numbers correctly.
         *         </p>
         * @see #getNaturalComparator()
         */
        public static Comparator<String> getNaturalComparator(final Collator collator) {
                if (collator == null) {
                        // it's important to explicitly handle this here - else the bug will manifest anytime later in possibly
                        // unrelated code that tries to use the comparator
                        throw new NullPointerException("collator must not be null");
                }
                return new Comparator<String>() {
                        
                        @Override
                        public int compare(String o1, String o2) {
                                return compareNatural(collator, o1, o2);
                        }
                };
        }
        
        /**
         * Returns a comparator that compares contained numbers based on their numeric values and
         * compares other parts based on each character's Unicode value.
         * 
         * @return <p>
         *         a string comparator that does case-sensitive comparisons on pure ascii strings and
         *         handles embedded numbers correctly.
         *         </p>
         *         <b>Do not use</b> if your app might ever run on any locale that uses more than 7-bit
         *         ascii characters.
         * @see #getNaturalComparator()
         * @see #getNaturalComparator(java.text.Collator)
         */
        public static Comparator<String> getNaturalComparatorAscii() {
                return NATURAL_COMPARATOR_ASCII;
        }
        
        /**
         * Returns a comparator that compares contained numbers based on their numeric values and
         * compares other parts based on each character's Unicode value while ignore upper/lower case
         * differences. <b>Do not use</b> if your app might ever run on any locale that uses more than
         * 7-bit ascii characters.
         * 
         * @return <p>
         *         a string comparator that does case insensitive comparisons on pure ascii strings and
         *         handles embedded numbers correctly.
         *         </p>
         * @see #getNaturalComparator()
         * @see #getNaturalComparator(java.text.Collator)
         */
        public static Comparator<String> getNaturalComparatorIgnoreCaseAscii() {
                return IGNORE_CASE_NATURAL_COMPARATOR_ASCII;
        }
        
        /**
         * <p>
         * Compares two strings using the current locale's rules and comparing contained numbers based
         * on their numeric values.
         * </p>
         * <p>
         * This is probably the best default comparison to use.
         * </p>
         * <p>
         * If you know that the texts to be compared are in a certain language that differs from the
         * default locale's language, then get a collator for the desired locale (
         * {@link java.text.Collator#getInstance(java.util.Locale)}) and pass it to
         * {@link #compareNatural(java.text.Collator, String, String)}
         * </p>
         * 
         * @param s first string
         * @param t second string
         * @return zero iff <code>s</code> and <code>t</code> are equal, a value less than zero iff
         *         <code>s</code> lexicographically precedes <code>t</code> and a value larger than zero
         *         iff <code>s</code> lexicographically follows <code>t</code>
         */
        public static int compareNatural(String s, String t) {
                return compareNatural(s, t, false, Collator.getInstance());
        }
        
        /**
         * <p>
         * Compares two strings using the given collator and comparing contained numbers based on their
         * numeric values.
         * </p>
         * 
         * @param s first string
         * @param t second string
         * @return zero iff <code>s</code> and <code>t</code> are equal, a value less than zero iff
         *         <code>s</code> lexicographically precedes <code>t</code> and a value larger than zero
         *         iff <code>s</code> lexicographically follows <code>t</code>
         */
        public static int compareNatural(Collator collator, String s, String t) {
                return compareNatural(s, t, true, collator);
        }
        
        /**
         * <p>
         * Compares two strings using each character's Unicode value for non-digit characters and the
         * numeric values off any contained numbers.
         * </p>
         * <p>
         * (This will probably make sense only for strings containing 7-bit ascii characters only.)
         * </p>
         * 
         * @return zero iff <code>s</code> and <code>t</code> are equal, a value less than zero iff
         *         <code>s</code> lexicographically precedes <code>t</code> and a value larger than zero
         *         iff <code>s</code> lexicographically follows <code>t</code>
         */
        public static int compareNaturalAscii(String s, String t) {
                return compareNatural(s, t, true, null);
        }
        
        /**
         * <p>
         * Compares two strings using each character's Unicode value - ignoring upper/lower case - for
         * non-digit characters and the numeric values of any contained numbers.
         * </p>
         * <p>
         * (This will probably make sense only for strings containing 7-bit ascii characters only.)
         * </p>
         * 
         * @return zero iff <code>s</code> and <code>t</code> are equal, a value less than zero iff
         *         <code>s</code> lexicographically precedes <code>t</code> and a value larger than zero
         *         iff <code>s</code> lexicographically follows <code>t</code>
         */
        public static int compareNaturalIgnoreCaseAscii(String s, String t) {
                return compareNatural(s, t, false, null);
        }
        
        /**
         * @param s first string
         * @param t second string
         * @param caseSensitive treat characters differing in case only as equal - will be ignored if a
         *            collator is given
         * @param collator used to compare subwords that aren't numbers - if null, characters will be
         *            compared individually based on their Unicode value
         * @return zero iff <code>s</code> and <code>t</code> are equal, a value less than zero iff
         *         <code>s</code> lexicographically precedes <code>t</code> and a value larger than zero
         *         iff <code>s</code> lexicographically follows <code>t</code>
         */
        private static int compareNatural(String s, String t, boolean caseSensitive, Collator collator) {
                int sIndex = 0;
                int tIndex = 0;
                
                int sLength = s.length();
                int tLength = t.length();
                
                while (true) {
                        // both character indices are after a subword (or at zero)
                        
                        // Check if one string is at end
                        if (sIndex == sLength && tIndex == tLength) {
                                return 0;
                        }
                        if (sIndex == sLength) {
                                return -1;
                        }
                        if (tIndex == tLength) {
                                return 1;
                        }
                        
                        // Compare sub word
                        char sChar = s.charAt(sIndex);
                        char tChar = t.charAt(tIndex);
                        
                        boolean sCharIsDigit = Character.isDigit(sChar);
                        boolean tCharIsDigit = Character.isDigit(tChar);
                        
                        if (sCharIsDigit && tCharIsDigit) {
                                // Compare numbers
                                
                                // skip leading 0s
                                int sLeadingZeroCount = 0;
                                while (sChar == '0') {
                                        ++sLeadingZeroCount;
                                        ++sIndex;
                                        if (sIndex == sLength) {
                                                break;
                                        }
                                        sChar = s.charAt(sIndex);
                                }
                                int tLeadingZeroCount = 0;
                                while (tChar == '0') {
                                        ++tLeadingZeroCount;
                                        ++tIndex;
                                        if (tIndex == tLength) {
                                                break;
                                        }
                                        tChar = t.charAt(tIndex);
                                }
                                boolean sAllZero = sIndex == sLength || !Character.isDigit(sChar);
                                boolean tAllZero = tIndex == tLength || !Character.isDigit(tChar);
                                if (sAllZero && tAllZero) {
                                        continue;
                                }
                                if (sAllZero && !tAllZero) {
                                        return -1;
                                }
                                if (tAllZero) {
                                        return 1;
                                }
                                
                                int diff = 0;
                                do {
                                        if (diff == 0) {
                                                diff = sChar - tChar;
                                        }
                                        ++sIndex;
                                        ++tIndex;
                                        if (sIndex == sLength && tIndex == tLength) {
                                                return diff != 0 ? diff : sLeadingZeroCount - tLeadingZeroCount;
                                        }
                                        if (sIndex == sLength) {
                                                if (diff == 0) {
                                                        return -1;
                                                }
                                                return Character.isDigit(t.charAt(tIndex)) ? -1 : diff;
                                        }
                                        if (tIndex == tLength) {
                                                if (diff == 0) {
                                                        return 1;
                                                }
                                                return Character.isDigit(s.charAt(sIndex)) ? 1 : diff;
                                        }
                                        sChar = s.charAt(sIndex);
                                        tChar = t.charAt(tIndex);
                                        sCharIsDigit = Character.isDigit(sChar);
                                        tCharIsDigit = Character.isDigit(tChar);
                                        if (!sCharIsDigit && !tCharIsDigit) {
                                                // both number sub words have the same length
                                                if (diff != 0) {
                                                        return diff;
                                                }
                                                break;
                                        }
                                        if (!sCharIsDigit) {
                                                return -1;
                                        }
                                        if (!tCharIsDigit) {
                                                return 1;
                                        }
                                } while (true);
                        } else {
                                // Compare words
                                if (collator != null) {
                                        // To use the collator the whole subwords have to be compared - character-by-character comparison
                                        // is not possible. So find the two subwords first
                                        int aw = sIndex;
                                        int bw = tIndex;
                                        do {
                                                ++sIndex;
                                        } while (sIndex < sLength && !Character.isDigit(s.charAt(sIndex)));
                                        do {
                                                ++tIndex;
                                        } while (tIndex < tLength && !Character.isDigit(t.charAt(tIndex)));
                                        
                                        String as = s.substring(aw, sIndex);
                                        String bs = t.substring(bw, tIndex);
                                        int subwordResult = collator.compare(as, bs);
                                        if (subwordResult != 0) {
                                                return subwordResult;
                                        }
                                } else {
                                        // No collator specified. All characters should be ascii only. Compare character-by-character.
                                        do {
                                                if (sChar != tChar) {
                                                        if (caseSensitive) {
                                                                return sChar - tChar;
                                                        }
                                                        sChar = Character.toUpperCase(sChar);
                                                        tChar = Character.toUpperCase(tChar);
                                                        if (sChar != tChar) {
                                                                sChar = Character.toLowerCase(sChar);
                                                                tChar = Character.toLowerCase(tChar);
                                                                if (sChar != tChar) {
                                                                        return sChar - tChar;
                                                                }
                                                        }
                                                }
                                                ++sIndex;
                                                ++tIndex;
                                                if (sIndex == sLength && tIndex == tLength) {
                                                        return 0;
                                                }
                                                if (sIndex == sLength) {
                                                        return -1;
                                                }
                                                if (tIndex == tLength) {
                                                        return 1;
                                                }
                                                sChar = s.charAt(sIndex);
                                                tChar = t.charAt(tIndex);
                                                sCharIsDigit = Character.isDigit(sChar);
                                                tCharIsDigit = Character.isDigit(tChar);
                                        } while (!sCharIsDigit && !tCharIsDigit);
                                }
                        }
                }
        }
}

1	/*
2	* Copyright (c) 2006, Stephen Kelvin Friedrich, All rights reserved.
3	*
4	* This a BSD license. If you use or enhance the code, I'd be pleased if you sent a mail to s.friedrich@eekboom.com
5	*
6	* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
7	* following conditions are met:
8	* * Redistributions of source code must retain the above copyright notice, this list of conditions and the
9	* following disclaimer.
10	* * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the
11	following disclaimer in the documentation and/or other materials provided with the distribution.
12	* * Neither the name of the "Stephen Kelvin Friedrich" nor the names of its contributors may be used to endorse
13	* or promote products derived from this software without specific prior written permission.
14	*
15	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
16	* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
17	* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
18	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
19	* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
20	* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
21	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
22	*/
23
24	package org.openmrs.util;
25
26	import java.text.Collator;
27	import java.util.Comparator;
28
29	/**
30	* Utility class for natural String comparison operations
31	*
32	* @since 1.5
33	*/
34	public final class NaturalStrings {
35
36	/**
37	* <p>
38	* A string comparator that does case-sensitive comparisons and handles embedded numbers
39	* correctly.
40	* </p>
41	* <p>
42	* <b>Do not use</b> if your app might ever run on any locale that uses more than 7-bit ascii
43	* characters.
44	* </p>
45	*/
46	private static final Comparator<String> NATURAL_COMPARATOR_ASCII = new Comparator<String>() {	1✔
47
48	@Override
49	public int compare(String o1, String o2) {
50	return compareNaturalAscii(o1, o2);	×
51	}
52	};
53
54	/**
55	* <p>
56	* A string comparator that does case insensitive comparisons and handles embedded numbers
57	* correctly.
58	* </p>
59	* <p>
60	* <b>Do not use</b> if your app might ever run on any locale that uses more than 7-bit ascii
61	* characters.
62	* </p>
63	*/
64	private static final Comparator<String> IGNORE_CASE_NATURAL_COMPARATOR_ASCII = new Comparator<String>() {	1✔
65
66	@Override
67	public int compare(String o1, String o2) {
68	return compareNaturalIgnoreCaseAscii(o1, o2);	×
69	}
70	};
71
72	/**
73	* This is a utility class (static methods only), don't instantiate.
74	*/
75	private NaturalStrings() {	×
76	}	×
77
78	/**
79	* Returns a comparator that compares contained numbers based on their numeric values and
80	* compares other parts using the current locale's order rules.
81	* <p>
82	* For example in German locale this will be a comparator that handles umlauts correctly and
83	* ignores upper/lower case differences.
84	* </p>
85	*
86	* @return <p>
87	* A string comparator that uses the current locale's order rules and handles embedded
88	* numbers correctly.
89	* </p>
90	* @see #getNaturalComparator(java.text.Collator)
91	*/
92	public static Comparator<String> getNaturalComparator() {
93	Collator collator = Collator.getInstance();	1✔
94	return getNaturalComparator(collator);	1✔
95	}
96
97	/**
98	* Returns a comparator that compares contained numbers based on their numeric values and
99	* compares other parts using the given collator.
100	*
101	* @param collator used for locale specific comparison of text (non-number) subwords - must not
102	* be null
103	* @return <p>
104	* A string comparator that uses the given Collator to compare subwords and handles
105	* embedded numbers correctly.
106	* </p>
107	* @see #getNaturalComparator()
108	*/
109	public static Comparator<String> getNaturalComparator(final Collator collator) {
110	if (collator == null) {	1✔
111	// it's important to explicitly handle this here - else the bug will manifest anytime later in possibly
112	// unrelated code that tries to use the comparator
113	throw new NullPointerException("collator must not be null");	×
114	}
115	return new Comparator<String>() {	1✔
116
117	@Override
118	public int compare(String o1, String o2) {
119	return compareNatural(collator, o1, o2);	1✔
120	}
121	};
122	}
123
124	/**
125	* Returns a comparator that compares contained numbers based on their numeric values and
126	* compares other parts based on each character's Unicode value.
127	*
128	* @return <p>
129	* a string comparator that does case-sensitive comparisons on pure ascii strings and
130	* handles embedded numbers correctly.
131	* </p>
132	* <b>Do not use</b> if your app might ever run on any locale that uses more than 7-bit
133	* ascii characters.
134	* @see #getNaturalComparator()
135	* @see #getNaturalComparator(java.text.Collator)
136	*/
137	public static Comparator<String> getNaturalComparatorAscii() {
138	return NATURAL_COMPARATOR_ASCII;	×
139	}
140
141	/**
142	* Returns a comparator that compares contained numbers based on their numeric values and
143	* compares other parts based on each character's Unicode value while ignore upper/lower case
144	* differences. <b>Do not use</b> if your app might ever run on any locale that uses more than
145	* 7-bit ascii characters.
146	*
147	* @return <p>
148	* a string comparator that does case insensitive comparisons on pure ascii strings and
149	* handles embedded numbers correctly.
150	* </p>
151	* @see #getNaturalComparator()
152	* @see #getNaturalComparator(java.text.Collator)
153	*/
154	public static Comparator<String> getNaturalComparatorIgnoreCaseAscii() {
155	return IGNORE_CASE_NATURAL_COMPARATOR_ASCII;	×
156	}
157
158	/**
159	* <p>
160	* Compares two strings using the current locale's rules and comparing contained numbers based
161	* on their numeric values.
162	* </p>
163	* <p>
164	* This is probably the best default comparison to use.
165	* </p>
166	* <p>
167	* If you know that the texts to be compared are in a certain language that differs from the
168	* default locale's language, then get a collator for the desired locale (
169	* {@link java.text.Collator#getInstance(java.util.Locale)}) and pass it to
170	* {@link #compareNatural(java.text.Collator, String, String)}
171	* </p>
172	*
173	* @param s first string
174	* @param t second string
175	* @return zero iff <code>s</code> and <code>t</code> are equal, a value less than zero iff
176	* <code>s</code> lexicographically precedes <code>t</code> and a value larger than zero
177	* iff <code>s</code> lexicographically follows <code>t</code>
178	*/
179	public static int compareNatural(String s, String t) {
180	return compareNatural(s, t, false, Collator.getInstance());	×
181	}
182
183	/**
184	* <p>
185	* Compares two strings using the given collator and comparing contained numbers based on their
186	* numeric values.
187	* </p>
188	*
189	* @param s first string
190	* @param t second string
191	* @return zero iff <code>s</code> and <code>t</code> are equal, a value less than zero iff
192	* <code>s</code> lexicographically precedes <code>t</code> and a value larger than zero
193	* iff <code>s</code> lexicographically follows <code>t</code>
194	*/
195	public static int compareNatural(Collator collator, String s, String t) {
196	return compareNatural(s, t, true, collator);	1✔
197	}
198
199	/**
200	* <p>
201	* Compares two strings using each character's Unicode value for non-digit characters and the
202	* numeric values off any contained numbers.
203	* </p>
204	* <p>
205	* (This will probably make sense only for strings containing 7-bit ascii characters only.)
206	* </p>
207	*
208	* @return zero iff <code>s</code> and <code>t</code> are equal, a value less than zero iff
209	* <code>s</code> lexicographically precedes <code>t</code> and a value larger than zero
210	* iff <code>s</code> lexicographically follows <code>t</code>
211	*/
212	public static int compareNaturalAscii(String s, String t) {
213	return compareNatural(s, t, true, null);	×
214	}
215
216	/**
217	* <p>
218	* Compares two strings using each character's Unicode value - ignoring upper/lower case - for
219	* non-digit characters and the numeric values of any contained numbers.
220	* </p>
221	* <p>
222	* (This will probably make sense only for strings containing 7-bit ascii characters only.)
223	* </p>
224	*
225	* @return zero iff <code>s</code> and <code>t</code> are equal, a value less than zero iff
226	* <code>s</code> lexicographically precedes <code>t</code> and a value larger than zero
227	* iff <code>s</code> lexicographically follows <code>t</code>
228	*/
229	public static int compareNaturalIgnoreCaseAscii(String s, String t) {
230	return compareNatural(s, t, false, null);	×
231	}
232
233	/**
234	* @param s first string
235	* @param t second string
236	* @param caseSensitive treat characters differing in case only as equal - will be ignored if a
237	* collator is given
238	* @param collator used to compare subwords that aren't numbers - if null, characters will be
239	* compared individually based on their Unicode value
240	* @return zero iff <code>s</code> and <code>t</code> are equal, a value less than zero iff
241	* <code>s</code> lexicographically precedes <code>t</code> and a value larger than zero
242	* iff <code>s</code> lexicographically follows <code>t</code>
243	*/
244	private static int compareNatural(String s, String t, boolean caseSensitive, Collator collator) {
245	int sIndex = 0;	1✔
246	int tIndex = 0;	1✔
247
248	int sLength = s.length();	1✔
249	int tLength = t.length();	1✔
250
251	while (true) {
252	// both character indices are after a subword (or at zero)
253
254	// Check if one string is at end
255	if (sIndex == sLength && tIndex == tLength) {	1✔
256	return 0;	×
257	}
258	if (sIndex == sLength) {	1✔
259	return -1;	×
260	}
261	if (tIndex == tLength) {	1✔
262	return 1;	×
263	}
264
265	// Compare sub word
266	char sChar = s.charAt(sIndex);	1✔
267	char tChar = t.charAt(tIndex);	1✔
268
269	boolean sCharIsDigit = Character.isDigit(sChar);	1✔
270	boolean tCharIsDigit = Character.isDigit(tChar);	1✔
271
272	if (sCharIsDigit && tCharIsDigit) {	1✔
273	// Compare numbers
274
275	// skip leading 0s
276	int sLeadingZeroCount = 0;	1✔
277	while (sChar == '0') {	1✔
278	++sLeadingZeroCount;	×
279	++sIndex;	×
280	if (sIndex == sLength) {	×
281	break;	×
282	}
283	sChar = s.charAt(sIndex);	×
284	}
285	int tLeadingZeroCount = 0;	1✔
286	while (tChar == '0') {	1✔
287	++tLeadingZeroCount;	×
288	++tIndex;	×
289	if (tIndex == tLength) {	×
290	break;	×
291	}
292	tChar = t.charAt(tIndex);	×
293	}
294	boolean sAllZero = sIndex == sLength \|\| !Character.isDigit(sChar);	1✔
295	boolean tAllZero = tIndex == tLength \|\| !Character.isDigit(tChar);	1✔
296	if (sAllZero && tAllZero) {	1✔
297	continue;	×
298	}
299	if (sAllZero && !tAllZero) {	1✔
300	return -1;	×
301	}
302	if (tAllZero) {	1✔
303	return 1;	×
304	}
305
306	int diff = 0;	1✔
307	do {
308	if (diff == 0) {	1✔
309	diff = sChar - tChar;	1✔
310	}
311	++sIndex;	1✔
312	++tIndex;	1✔
313	if (sIndex == sLength && tIndex == tLength) {	1✔
314	return diff != 0 ? diff : sLeadingZeroCount - tLeadingZeroCount;	1✔
315	}
316	if (sIndex == sLength) {	1✔
317	if (diff == 0) {	×
318	return -1;	×
319	}
320	return Character.isDigit(t.charAt(tIndex)) ? -1 : diff;	×
321	}
322	if (tIndex == tLength) {	1✔
323	if (diff == 0) {	1✔
324	return 1;	×
325	}
326	return Character.isDigit(s.charAt(sIndex)) ? 1 : diff;	1✔
327	}
328	sChar = s.charAt(sIndex);	×
329	tChar = t.charAt(tIndex);	×
330	sCharIsDigit = Character.isDigit(sChar);	×
331	tCharIsDigit = Character.isDigit(tChar);	×
332	if (!sCharIsDigit && !tCharIsDigit) {	×
333	// both number sub words have the same length
334	if (diff != 0) {	×
335	return diff;	×
336	}
337	break;
338	}
339	if (!sCharIsDigit) {	×
340	return -1;	×
341	}
342	if (!tCharIsDigit) {	×
343	return 1;	×
344	}
345	} while (true);
346	} else {	×
347	// Compare words
348	if (collator != null) {	1✔
349	// To use the collator the whole subwords have to be compared - character-by-character comparison
350	// is not possible. So find the two subwords first
351	int aw = sIndex;	1✔
352	int bw = tIndex;	1✔
353	do {
354	++sIndex;	1✔
355	} while (sIndex < sLength && !Character.isDigit(s.charAt(sIndex)));	1✔
356	do {
357	++tIndex;	1✔
358	} while (tIndex < tLength && !Character.isDigit(t.charAt(tIndex)));	1✔
359
360	String as = s.substring(aw, sIndex);	1✔
361	String bs = t.substring(bw, tIndex);	1✔
362	int subwordResult = collator.compare(as, bs);	1✔
363	if (subwordResult != 0) {	1✔
364	return subwordResult;	×
365	}
366	} else {	1✔
367	// No collator specified. All characters should be ascii only. Compare character-by-character.
368	do {
369	if (sChar != tChar) {	×
370	if (caseSensitive) {	×
371	return sChar - tChar;	×
372	}
373	sChar = Character.toUpperCase(sChar);	×
374	tChar = Character.toUpperCase(tChar);	×
375	if (sChar != tChar) {	×
376	sChar = Character.toLowerCase(sChar);	×
377	tChar = Character.toLowerCase(tChar);	×
378	if (sChar != tChar) {	×
379	return sChar - tChar;	×
380	}
381	}
382	}
383	++sIndex;	×
384	++tIndex;	×
385	if (sIndex == sLength && tIndex == tLength) {	×
386	return 0;	×
387	}
388	if (sIndex == sLength) {	×
389	return -1;	×
390	}
391	if (tIndex == tLength) {	×
392	return 1;	×
393	}
394	sChar = s.charAt(sIndex);	×
395	tChar = t.charAt(tIndex);	×
396	sCharIsDigit = Character.isDigit(sChar);	×
397	tCharIsDigit = Character.isDigit(tChar);	×
398	} while (!sCharIsDigit && !tCharIsDigit);	×
399	}
400	}
401	}	1✔
402	}
403	}

openmrs / openmrs-core / 5584

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous