1 package org.apache.maven.surefire.util.internal;
2
3 /*
4 * Licensed to the Apache Software Foundation (ASF) under one
5 * or more contributor license agreements. See the NOTICE file
6 * distributed with this work for additional information
7 * regarding copyright ownership. The ASF licenses this file
8 * to you under the Apache License, Version 2.0 (the
9 * "License"); you may not use this file except in compliance
10 * with the License. You may obtain a copy of the License at
11 *
12 * http://www.apache.org/licenses/LICENSE-2.0
13 *
14 * Unless required by applicable law or agreed to in writing,
15 * software distributed under the License is distributed on an
16 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
17 * KIND, either express or implied. See the License for the
18 * specific language governing permissions and limitations
19 * under the License.
20 */
21
22 import java.nio.ByteBuffer;
23 import java.nio.CharBuffer;
24 import java.nio.charset.CharacterCodingException;
25 import java.nio.charset.Charset;
26 import java.util.StringTokenizer;
27
28 /**
29 * <p>
30 * Common {@link String java.lang.String} manipulation routines.
31 * </p>
32 * <br>
33 * <p>
34 * Originally from <a href="http://jakarta.apache.org/turbine/">Turbine</a> and the GenerationJavaCore library.
35 * </p>
36 * <br>
37 * NOTE: This class is not part of any api and is public purely for technical reasons !
38 *
39 * @author <a href="mailto:jon@latchkey.com">Jon S. Stevens</a>
40 * @author <a href="mailto:dlr@finemaltcoding.com">Daniel Rall</a>
41 * @author <a href="mailto:gcoladonato@yahoo.com">Greg Coladonato</a>
42 * @author <a href="mailto:bayard@generationjava.com">Henri Yandell</a>
43 * @author <a href="mailto:ed@codehaus.org">Ed Korthof</a>
44 * @author <a href="mailto:rand_mcneely@yahoo.com">Rand McNeely</a>
45 * @author Stephen Colebourne
46 * @author <a href="mailto:fredrik@westermarck.com">Fredrik Westermarck</a>
47 * @author Holger Krauth
48 * @author <a href="mailto:alex@purpletech.com">Alexander Day Chaffee</a>
49 * @author <a href="mailto:vincent.siveton@gmail.com">Vincent Siveton</a>
50 * @version $Id: StringUtils.java 8001 2009-01-03 13:17:09Z vsiveton $
51 * @since 1.0
52 */
53 public final class StringUtils
54 {
55 public static final String NL = System.getProperty( "line.separator" );
56
57 private static final byte[] HEX_CHARS = {
58 '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
59
60 private static final Charset DEFAULT_CHARSET = Charset.defaultCharset();
61
62 /**
63 * TODO
64 * Use JDK7 StandardCharsets
65 */
66 public static final Charset US_ASCII = Charset.forName( "US-ASCII" );
67
68 // 8-bit charset Latin-1
69 public static final Charset ISO_8859_1 = Charset.forName( "ISO-8859-1" );
70
71 public static final Charset UTF_8 = Charset.forName( "UTF-8" );
72
73 private StringUtils()
74 {
75 throw new IllegalStateException( "no instantiable constructor" );
76 }
77
78 public static String[] split( String text, String separator )
79 {
80 final StringTokenizer tok;
81 if ( separator == null )
82 {
83 // Null separator means we're using StringTokenizer's default
84 // delimiter, which comprises all whitespace characters.
85 tok = new StringTokenizer( text );
86 }
87 else
88 {
89 tok = new StringTokenizer( text, separator );
90 }
91
92 String[] list = new String[tok.countTokens()];
93 for ( int i = 0; tok.hasMoreTokens(); i++ )
94 {
95 list[i] = tok.nextToken();
96 }
97 return list;
98 }
99
100 /**
101 * <p>
102 * Checks if a (trimmed) String is {@code null} or blank.
103 * </p>
104 *
105 * @param str the String to check
106 * @return {@code true} if the String is {@code null}, or length zero once trimmed
107 */
108 public static boolean isBlank( String str )
109 {
110 return str == null || str.trim().isEmpty();
111 }
112
113 /**
114 * <p>
115 * Checks if a (trimmed) String is not {@code null} and not blank.
116 * </p>
117 *
118 * @param str the String to check
119 * @return {@code true} if the String is not {@code null} and length of trimmed {@code str} is not zero.
120 */
121 public static boolean isNotBlank( String str )
122 {
123 return !isBlank( str );
124 }
125
126 /**
127 * Escape the specified string to a representation that only consists of nicely printable characters, without any
128 * newlines and without a comma.
129 * <p>
130 * The reverse-method is {@link #unescapeString(StringBuilder, CharSequence)}.
131 *
132 * @param target target string buffer. The required space will be up to {@code str.getBytes().length * 5} chars.
133 * @param str String to escape values in, may be {@code null}.
134 */
135 @SuppressWarnings( "checkstyle:magicnumber" )
136 public static void escapeToPrintable( StringBuilder target, CharSequence str )
137 {
138 if ( target == null )
139 {
140 throw new IllegalArgumentException( "The target buffer must not be null" );
141 }
142 if ( str == null )
143 {
144 return;
145 }
146
147 for ( int i = 0; i < str.length(); i++ )
148 {
149 char c = str.charAt( i );
150
151 // handle non-nicely printable chars and the comma
152 if ( c < 32 || c > 126 || c == '\\' || c == ',' )
153 {
154 target.append( '\\' );
155 target.append( (char) HEX_CHARS[( 0xF000 & c ) >> 12] );
156 target.append( (char) HEX_CHARS[( 0x0F00 & c ) >> 8] );
157 target.append( (char) HEX_CHARS[( 0x00F0 & c ) >> 4] );
158 target.append( (char) HEX_CHARS[( 0x000F & c )] );
159 }
160 else
161 {
162 target.append( c );
163 }
164 }
165 }
166
167 /**
168 * Reverses the effect of {@link #escapeToPrintable(StringBuilder, CharSequence)}.
169 *
170 * @param target target string buffer
171 * @param str the String to un-escape, as created by {@link #escapeToPrintable(StringBuilder, CharSequence)}
172 */
173 public static void unescapeString( StringBuilder target, CharSequence str )
174 {
175 if ( target == null )
176 {
177 throw new IllegalArgumentException( "The target buffer must not be null" );
178 }
179 if ( str == null )
180 {
181 return;
182 }
183
184 for ( int i = 0; i < str.length(); i++ )
185 {
186 char ch = str.charAt( i );
187
188 if ( ch == '\\' )
189 {
190 target.append( (char) (
191 digit( str.charAt( ++i ) ) << 12
192 | digit( str.charAt( ++i ) ) << 8
193 | digit( str.charAt( ++i ) ) << 4
194 | digit( str.charAt( ++i ) )
195 ) );
196 }
197 else
198 {
199 target.append( ch );
200 }
201 }
202 }
203
204 private static int digit( char ch )
205 {
206 if ( ch >= 'a' )
207 {
208 return 10 + ch - 'a';
209 }
210 else if ( ch >= 'A' )
211 {
212 return 10 + ch - 'A';
213 }
214 else
215 {
216 return ch - '0';
217 }
218 }
219
220 /**
221 * Escapes the bytes in the array {@code str} to contain only 'printable' bytes.
222 * <p>
223 * Escaping is done by encoding the non-nicely printable bytes to {@code '\' + upperCaseHexBytes(byte)}.
224 * <p>
225 * A save length of {@code out} is {@code len * 3 + outoff}.
226 * <p>
227 * The reverse-method is {@link #unescapeBytes(String, String)}.
228 *
229 * @param out output buffer
230 * @param outoff offset in the output buffer
231 * @param input input buffer
232 * @param off offset in the input buffer
233 * @param len number of bytes to copy from the input buffer
234 * @return number of bytes written to {@code out}
235 */
236 @SuppressWarnings( "checkstyle:magicnumber" )
237 public static int escapeBytesToPrintable( byte[] out, int outoff, byte[] input, int off, int len )
238 {
239 if ( out == null )
240 {
241 throw new IllegalArgumentException( "The output array must not be null" );
242 }
243 if ( input == null || input.length == 0 )
244 {
245 return 0;
246 }
247 int outputPos = outoff;
248 int end = off + len;
249 for ( int i = off; i < end; i++ )
250 {
251 byte b = input[i];
252
253 // handle non-nicely printable bytes
254 if ( b < 32 || b > 126 || b == '\\' || b == ',' )
255 {
256 int upper = ( 0xF0 & b ) >> 4;
257 int lower = ( 0x0F & b );
258 out[outputPos++] = '\\';
259 out[outputPos++] = HEX_CHARS[upper];
260 out[outputPos++] = HEX_CHARS[lower];
261 }
262 else
263 {
264 out[outputPos++] = b;
265 }
266 }
267
268 return outputPos - outoff;
269 }
270
271 /**
272 * Reverses the effect of {@link #escapeBytesToPrintable(byte[], int, byte[], int, int)}.
273 *
274 * @param str the input String
275 * @param charsetName the charset name
276 * @return the number of bytes written to {@code out}
277 */
278 public static ByteBuffer unescapeBytes( String str, String charsetName )
279 {
280 int outPos = 0;
281
282 if ( str == null )
283 {
284 return ByteBuffer.wrap( new byte[0] );
285 }
286
287 byte[] out = new byte[str.length()];
288 for ( int i = 0; i < str.length(); i++ )
289 {
290 char ch = str.charAt( i );
291
292 if ( ch == '\\' )
293 {
294 int upper = digit( str.charAt( ++i ) );
295 int lower = digit( str.charAt( ++i ) );
296 out[outPos++] = (byte) ( upper << 4 | lower );
297 }
298 else
299 {
300 out[outPos++] = (byte) ch;
301 }
302 }
303
304 Charset sourceCharset = Charset.forName( charsetName );
305 if ( !DEFAULT_CHARSET.equals( sourceCharset ) )
306 {
307 CharBuffer decodedFromSourceCharset;
308 try
309 {
310 decodedFromSourceCharset = sourceCharset.newDecoder().decode( ByteBuffer.wrap( out, 0, outPos ) );
311 return DEFAULT_CHARSET.encode( decodedFromSourceCharset );
312 }
313 catch ( CharacterCodingException e )
314 {
315 // ignore and fall through to the non-recoded version
316 }
317 }
318
319 return ByteBuffer.wrap( out, 0, outPos );
320 }
321
322 public static byte[] encodeStringForForkCommunication( String string )
323 {
324 return string.getBytes( ISO_8859_1 );
325 }
326
327 /**
328 * Determines if {@code buffer} starts with specific literal(s).
329 *
330 * @param buffer Examined StringBuffer
331 * @param pattern a pattern which should start in {@code buffer}
332 * @return {@code true} if buffer's literal starts with given {@code pattern}, or both are empty.
333 */
334 public static boolean startsWith( StringBuffer buffer, String pattern )
335 {
336 if ( buffer.length() < pattern.length() )
337 {
338 return false;
339 }
340 else
341 {
342 for ( int i = 0, len = pattern.length(); i < len; i++ )
343 {
344 if ( buffer.charAt( i ) != pattern.charAt( i ) )
345 {
346 return false;
347 }
348 }
349 return true;
350 }
351 }
352 }