| /******************************************************************************* |
| * Copyright (c) 2009, 2010 IBM Corporation and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.wst.jsdt.debug.rhino.tests; |
| |
| import java.io.File; |
| import java.io.FileInputStream; |
| import java.io.FileNotFoundException; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.net.URL; |
| import java.nio.ByteBuffer; |
| import java.nio.charset.Charset; |
| import java.nio.charset.CharsetDecoder; |
| import java.nio.charset.CodingErrorAction; |
| import java.nio.charset.IllegalCharsetNameException; |
| import java.nio.charset.UnsupportedCharsetException; |
| |
| import org.eclipse.core.runtime.FileLocator; |
| import org.eclipse.core.runtime.IPath; |
| import org.eclipse.core.runtime.Path; |
| import org.eclipse.core.runtime.Platform; |
| |
| /** |
| * Collection of utility methods for tests |
| * |
| * @since 1.0 |
| */ |
| public class Util { |
| |
| /** |
| * BiDi |
| * @since 1.1 |
| */ |
| public static final String UTF_8 = "UTF-8"; |
| /** |
| * The name of the source container <code>scripts</code> in the test bundle |
| * @since 1.1 |
| */ |
| public static final String SRC_SCRIPTS_CONTAINER = "scripts"; |
| |
| /** |
| * Constant representing the default size to read from an input stream |
| * @since 1.1 |
| */ |
| private static final int DEFAULT_READING_SIZE = 8192; |
| |
| /** |
| * Returns the int value of the given {@link Number} |
| * @param number |
| * @return |
| */ |
| public static int numberAsInt(Object number) { |
| return ((Number) number).intValue(); |
| } |
| |
| /** |
| * Returns the OS path to the directory that contains the test plugin. |
| * |
| * @since 1.1 |
| */ |
| public static IPath getPluginDirectoryPath() { |
| if (Platform.isRunning()) { |
| try { |
| URL platformURL = Platform.getBundle("org.eclipse.wst.jsdt.debug.rhino.tests").getEntry("/"); |
| return new Path(new File(FileLocator.toFileURL(platformURL).getFile()).getAbsolutePath()); |
| } catch (IOException e) { |
| e.printStackTrace(); |
| } |
| } |
| return new Path(System.getProperty("user.dir")); |
| } |
| |
| /** |
| * Loads the test source with the given name. If the source does not exist |
| * a {@link FileNotFoundException} is thrown. |
| * |
| * @param container the folder in the test project containing the source |
| * @param sourcename the name of the source file to load |
| * |
| * @return the {@link String} representation of the source or <code>null</code> |
| * @throws FileNotFoundException if the source does not exist |
| * @since 1.1 |
| */ |
| public static String getTestSource(String container, String sourcename) { |
| return getFileContentAsString(getPluginDirectoryPath().append(container).append(sourcename).toFile()); |
| } |
| |
| /** |
| * Returns the contents of the given file as a string, or <code>null</code> |
| * |
| * @param file the file to get the contents for |
| * @return the contents of the file as a {@link String} or <code>null</code> |
| * @since 1.1 |
| */ |
| public static String getFileContentAsString(File file) { |
| String contents = null; |
| FileInputStream stream = null; |
| try { |
| stream = new FileInputStream(file); |
| char[] array = getInputStreamAsCharArray(stream, -1, "UTF-8"); |
| contents = new String(array); |
| } |
| catch(IOException ioe) { |
| ioe.printStackTrace(); |
| } finally { |
| if (stream != null) { |
| try { |
| stream.close(); |
| } catch (IOException e) { |
| // ignore |
| } |
| } |
| } |
| return contents; |
| } |
| |
| /** |
| * Returns the given input stream's contents as a character array. |
| * If a length is specified (i.e. if length != -1), this represents the number of bytes in the stream. |
| * Note the specified stream is not closed in this method |
| * |
| * @param stream the stream to get convert to the char array |
| * @param length the length of the input stream, or -1 if unknown |
| * @param encoding the encoding to use when reading the stream |
| * @return the given input stream's contents as a character array. |
| * @throws IOException if a problem occurred reading the stream. |
| * @since 1.1 |
| */ |
| public static char[] getInputStreamAsCharArray(InputStream stream, int length, String encoding) throws IOException { |
| Charset charset = null; |
| try { |
| charset = Charset.forName(encoding); |
| } catch (IllegalCharsetNameException e) { |
| System.err.println("Illegal charset name : " + encoding); //$NON-NLS-1$ |
| return null; |
| } catch(UnsupportedCharsetException e) { |
| System.err.println("Unsupported charset : " + encoding); //$NON-NLS-1$ |
| return null; |
| } |
| CharsetDecoder charsetDecoder = charset.newDecoder(); |
| charsetDecoder.onMalformedInput(CodingErrorAction.REPLACE).onUnmappableCharacter(CodingErrorAction.REPLACE); |
| byte[] contents = getInputStreamAsByteArray(stream, length); |
| ByteBuffer byteBuffer = ByteBuffer.allocate(contents.length); |
| byteBuffer.put(contents); |
| byteBuffer.flip(); |
| return charsetDecoder.decode(byteBuffer).array(); |
| } |
| |
| /** |
| * Returns the given input stream as a byte array |
| * |
| * @param stream the stream to get as a byte array |
| * @param length the length to read from the stream or -1 for unknown |
| * @return the given input stream as a byte array |
| * @throws IOException |
| * @since 1.1 |
| */ |
| public static byte[] getInputStreamAsByteArray(InputStream stream, int length) throws IOException { |
| byte[] contents; |
| if (length == -1) { |
| contents = new byte[0]; |
| int contentsLength = 0; |
| int amountRead = -1; |
| do { |
| // read at least 8K |
| int amountRequested = Math.max(stream.available(), DEFAULT_READING_SIZE); |
| // resize contents if needed |
| if (contentsLength + amountRequested > contents.length) { |
| System.arraycopy(contents, |
| 0, |
| contents = new byte[contentsLength + amountRequested], |
| 0, |
| contentsLength); |
| } |
| // read as many bytes as possible |
| amountRead = stream.read(contents, contentsLength, amountRequested); |
| if (amountRead > 0) { |
| // remember length of contents |
| contentsLength += amountRead; |
| } |
| } while (amountRead != -1); |
| // resize contents if necessary |
| if (contentsLength < contents.length) { |
| System.arraycopy(contents, 0, contents = new byte[contentsLength], 0, contentsLength); |
| } |
| } else { |
| contents = new byte[length]; |
| int len = 0; |
| int readSize = 0; |
| while ((readSize != -1) && (len != length)) { |
| // See PR 1FMS89U |
| // We record first the read size. In this case length is the actual |
| // read size. |
| len += readSize; |
| readSize = stream.read(contents, len, length - len); |
| } |
| } |
| return contents; |
| } |
| } |