mirror of
https://github.com/i-net-software/JWebAssembly.git
synced 2025-03-22 14:24:30 +01:00
780 lines
28 KiB
Java
780 lines
28 KiB
Java
/*
|
|
* Copyright 2017 - 2022 Volker Berlin (i-net software)
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
package de.inetsoftware.jwebassembly;
|
|
|
|
import static org.junit.Assert.assertEquals;
|
|
import static org.junit.Assert.assertTrue;
|
|
import static org.junit.Assert.fail;
|
|
|
|
import java.io.ByteArrayOutputStream;
|
|
import java.io.File;
|
|
import java.io.FileInputStream;
|
|
import java.io.FileOutputStream;
|
|
import java.io.IOException;
|
|
import java.io.InputStream;
|
|
import java.io.InputStreamReader;
|
|
import java.io.OutputStreamWriter;
|
|
import java.lang.ProcessBuilder.Redirect;
|
|
import java.lang.reflect.InvocationTargetException;
|
|
import java.lang.reflect.Method;
|
|
import java.net.URL;
|
|
import java.nio.charset.StandardCharsets;
|
|
import java.nio.file.Files;
|
|
import java.util.Arrays;
|
|
import java.util.Collection;
|
|
import java.util.Collections;
|
|
import java.util.HashMap;
|
|
import java.util.Map;
|
|
import java.util.Map.Entry;
|
|
import java.util.concurrent.TimeUnit;
|
|
import java.util.logging.Level;
|
|
|
|
import javax.annotation.Nonnull;
|
|
|
|
import org.junit.rules.TemporaryFolder;
|
|
|
|
import com.google.gson.Gson;
|
|
|
|
/**
|
|
* A Junit Rule that compile the given classes and compare the results from node and Java.
|
|
*
|
|
* @author Volker Berlin
|
|
*/
|
|
public class WasmRule extends TemporaryFolder {
|
|
|
|
private static final boolean IS_WINDOWS = System.getProperty( "os.name" ).toLowerCase().indexOf( "win" ) >= 0;
|
|
|
|
private static final SpiderMonkey spiderMonkey = new SpiderMonkey();
|
|
|
|
private static final Node node = new Node();
|
|
|
|
private static final Wat2Wasm wat2Wasm = new Wat2Wasm();
|
|
|
|
private static boolean npmWabtNightly;
|
|
|
|
private static String nodeModulePath;
|
|
|
|
private final Class<?>[] classes;
|
|
|
|
private final JWebAssembly compiler;
|
|
|
|
private Map<ScriptEngine, Object> compiledFiles = new HashMap<>(); // File or Throwable
|
|
|
|
private Map<ScriptEngine, File> scriptFiles = new HashMap<>();
|
|
|
|
private boolean failed;
|
|
|
|
private Map<String, Object[]> testData;
|
|
|
|
private Map<ScriptEngine, Map<String, String>> testResults;
|
|
|
|
/**
|
|
* Compile the given classes to a Wasm and save it to a file.
|
|
*
|
|
* @param classes
|
|
* list of classes to compile
|
|
*/
|
|
public WasmRule( Class<?>... classes ) {
|
|
if( classes == null || classes.length == 0 ) {
|
|
throw new IllegalArgumentException( "You need to set minimum one test class" );
|
|
}
|
|
this.classes = classes;
|
|
compiler = new JWebAssembly();
|
|
for( Class<?> clazz : classes ) {
|
|
URL url = clazz.getResource( '/' + clazz.getName().replace( '.', '/' ) + ".class" );
|
|
compiler.addFile( url );
|
|
}
|
|
|
|
// add the libraries that it can be scanned for annotations
|
|
final String[] libraries = System.getProperty("java.class.path").split(File.pathSeparator);
|
|
for( String lib : libraries ) {
|
|
if( lib.endsWith( ".jar" ) || lib.toLowerCase().contains( "jwebassembly-api" ) ) {
|
|
File library = new File(lib);
|
|
if( library.exists() ) {
|
|
compiler.addLibrary( library );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Set the parameter of a test.
|
|
*
|
|
* @param params
|
|
* the parameters with [ScriptEngine,method name,method parameters]
|
|
*/
|
|
public void setTestParameters( Collection<Object[]> params ) {
|
|
testData = new HashMap<>();
|
|
for( Object[] param : params ) {
|
|
testData.put( (String)param[1], (Object[])param[2] );
|
|
}
|
|
testResults = new HashMap<>();
|
|
}
|
|
|
|
/**
|
|
* Set property to control the behavior of the compiler
|
|
*
|
|
* @param key
|
|
* the key
|
|
* @param value
|
|
* the new value
|
|
*/
|
|
public void setProperty( String key, String value ) {
|
|
compiler.setProperty( key, value );
|
|
}
|
|
|
|
/**
|
|
* {@inheritDoc}
|
|
*/
|
|
@Override
|
|
protected void before() throws Throwable {
|
|
super.before();
|
|
if( testData != null ) {
|
|
writeJsonTestData( testData );
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Prepare the rule for the script engine
|
|
*
|
|
* @param script
|
|
* the script engine
|
|
* @throws Exception
|
|
* if any error occur
|
|
*/
|
|
public void before( ScriptEngine script ) throws Exception {
|
|
switch( script ) {
|
|
case Wat2Wasm:
|
|
case Wat2WasmGC:
|
|
// this is already part of execute and not only a compile
|
|
return;
|
|
default:
|
|
createCommand( script );
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Write the test data as JSON file.
|
|
*
|
|
* @param data
|
|
* the data
|
|
* @throws IOException
|
|
* if any IO error occur
|
|
*/
|
|
private void writeJsonTestData( Map<String, Object[]> data ) throws IOException {
|
|
// a character we need to convert an integer
|
|
HashMap<String, Object[]> copy = new HashMap<>( data );
|
|
for( Entry<String, Object[]> entry : copy.entrySet() ) {
|
|
Object[] params = entry.getValue();
|
|
for( int i = 0; i < params.length; i++ ) {
|
|
if( params[i] instanceof Character ) {
|
|
params = Arrays.copyOf( params, params.length );
|
|
params[i] = new Integer( ((Character)params[i]).charValue() );
|
|
entry.setValue( params );
|
|
}
|
|
}
|
|
}
|
|
try (OutputStreamWriter jsonData = new OutputStreamWriter( new FileOutputStream( new File( getRoot(), "testdata.json" ) ), StandardCharsets.UTF_8 )) {
|
|
new Gson().toJson( copy, jsonData );
|
|
}
|
|
}
|
|
|
|
/**
|
|
* {@inheritDoc}
|
|
*/
|
|
@Override
|
|
protected void after() {
|
|
if( failed || JWebAssembly.LOGGER.isLoggable( Level.FINE )) {
|
|
File watFile = null;
|
|
boolean wasJsFile = false;
|
|
boolean wasFiles = false;
|
|
for( Object fileOrException : compiledFiles.values() ) {
|
|
if( !(fileOrException instanceof File) ) {
|
|
continue;
|
|
}
|
|
wasFiles = true;
|
|
File wasmFile = (File)fileOrException;
|
|
File jsFile;
|
|
if( wasmFile.getName().endsWith( ".wasm" ) ) {
|
|
jsFile = new File( wasmFile.toString() + ".js" );
|
|
} else if( wasmFile.getName().endsWith( ".wat" ) ) {
|
|
if( wasmFile.isFile() ) {
|
|
watFile = wasmFile;
|
|
}
|
|
String name = wasmFile.toString();
|
|
jsFile = new File( name.substring( 0, name.length() - 4 ) + ".wasm.js" );
|
|
} else {
|
|
continue;
|
|
}
|
|
if( !wasJsFile && jsFile.isFile() ) {
|
|
try {
|
|
wasJsFile = true;
|
|
System.out.println( new String( Files.readAllBytes( jsFile.toPath() ), StandardCharsets.UTF_8 ) );
|
|
System.out.println();
|
|
} catch( IOException e ) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
}
|
|
try {
|
|
String textCompiled;
|
|
if( watFile != null ) {
|
|
textCompiled = new String( Files.readAllBytes( watFile.toPath() ), StandardCharsets.UTF_8 );
|
|
} else {
|
|
textCompiled = compiler.compileToText();
|
|
}
|
|
System.out.println( textCompiled );
|
|
System.out.println();
|
|
} catch( IOException e ) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
super.after();
|
|
}
|
|
|
|
/**
|
|
* Compile the classes of the test.
|
|
*
|
|
* @throws WasmException
|
|
* if the compiling is failing
|
|
*/
|
|
public void compile() throws WasmException {
|
|
try {
|
|
create();
|
|
} catch( Throwable ex ) {
|
|
throwException( ex );
|
|
}
|
|
compile( ScriptEngine.NodeJS );
|
|
}
|
|
|
|
/**
|
|
* Compile the classes of the script engine if not already compiled.
|
|
*
|
|
* @param script
|
|
* the script engine
|
|
* @return the compiled main file
|
|
* @throws WasmException
|
|
* if the compiling is failing
|
|
*/
|
|
public File compile( ScriptEngine script ) throws WasmException {
|
|
Object fileOrException = compiledFiles.get( script );
|
|
if( fileOrException instanceof File ) {
|
|
// compile only once
|
|
return (File)fileOrException;
|
|
}
|
|
if( fileOrException instanceof Throwable ) {
|
|
throwException( (Throwable)fileOrException );
|
|
}
|
|
|
|
compiler.setProperty( JWebAssembly.DEBUG_NAMES, "true" );
|
|
assertEquals( "true", compiler.getProperty( JWebAssembly.DEBUG_NAMES ) );
|
|
compiler.setProperty( JWebAssembly.WASM_USE_GC, script.useGC );
|
|
|
|
File file = null;
|
|
try {
|
|
String name = script.name();
|
|
if( name.contains( "Wat" ) ) {
|
|
file = newFile( name + ".wat" );
|
|
compiler.compileToText( file );
|
|
} else {
|
|
file = newFile( name + ".wasm" );
|
|
compiler.compileToBinary( file );
|
|
}
|
|
compiledFiles.put( script, file );
|
|
} catch( Throwable ex ) {
|
|
compiledFiles.put( script, ex );
|
|
throwException( ex );
|
|
}
|
|
return file;
|
|
}
|
|
|
|
/**
|
|
* Prepare the node node script.
|
|
*
|
|
* @param script
|
|
* the script engine
|
|
* @return the script file
|
|
* @throws IOException
|
|
* if any error occur.
|
|
*/
|
|
private File prepareNodeJs( ScriptEngine script ) throws IOException {
|
|
File scriptFile = scriptFiles.get( script );
|
|
if( scriptFile == null ) {
|
|
compile( script );
|
|
scriptFile = createScript( script, "nodetest.js", "{test}", script.name() );
|
|
scriptFiles.put( script, scriptFile );
|
|
}
|
|
return scriptFile;
|
|
}
|
|
|
|
/**
|
|
* Prepare the node wabt module.
|
|
*
|
|
* @param script
|
|
* the script engine
|
|
* @return the script file
|
|
* @throws Exception
|
|
* if any error occur.
|
|
*/
|
|
private File prepareNodeWat( ScriptEngine script ) throws Exception {
|
|
File scriptFile = scriptFiles.get( script );
|
|
if( scriptFile == null ) {
|
|
compile( script );
|
|
scriptFile = createScript( script, "WatTest.js", "{test}", script.name() );
|
|
scriptFiles.put( script, scriptFile );
|
|
|
|
if( !npmWabtNightly ) {
|
|
npmWabtNightly = true;
|
|
ProcessBuilder processBuilder = new ProcessBuilder( "npm", "install", "-g", "wabt@nightly" );
|
|
if( IS_WINDOWS ) {
|
|
processBuilder.command().add( 0, "cmd" );
|
|
processBuilder.command().add( 1, "/C" );
|
|
} else {
|
|
processBuilder.command().add( 0, "sudo" ); // with Github actions there is no write right
|
|
}
|
|
execute( processBuilder );
|
|
}
|
|
}
|
|
return scriptFile;
|
|
}
|
|
|
|
/**
|
|
* Get the path of the global installed module pathes.
|
|
*
|
|
* @return the path
|
|
* @throws Exception
|
|
* if any error occur.
|
|
*/
|
|
private static String getNodeModulePath() throws Exception {
|
|
if( nodeModulePath == null ) {
|
|
ProcessBuilder processBuilder = new ProcessBuilder( "npm", "root", "-g" );
|
|
if( IS_WINDOWS ) {
|
|
processBuilder.command().add( 0, "cmd" );
|
|
processBuilder.command().add( 1, "/C" );
|
|
}
|
|
Process process = processBuilder.start();
|
|
process.waitFor();
|
|
nodeModulePath = readStream( process.getInputStream(), false ).trim(); // module install path
|
|
System.out.println( "node global module path: " + nodeModulePath );
|
|
|
|
}
|
|
return nodeModulePath;
|
|
}
|
|
|
|
/**
|
|
* Prepare the Wat2Wasm tool if not already do. Fire an JUnit fail if the process produce an error.
|
|
*
|
|
* @param script
|
|
* the script engine
|
|
* @return the script file
|
|
* @throws Exception
|
|
* if any error occur.
|
|
*/
|
|
private File prepareWat2Wasm( ScriptEngine script ) throws Exception {
|
|
File scriptFile = scriptFiles.get( script );
|
|
if( scriptFile == null ) {
|
|
File watFile = compile( script );
|
|
String cmd = wat2Wasm.getCommand();
|
|
File wat2WasmFile = new File( getRoot(), script.name() + ".wasm" );
|
|
// the wat2wasm tool
|
|
ProcessBuilder processBuilder =
|
|
new ProcessBuilder( cmd, watFile.toString(), "-o", wat2WasmFile.toString(), "--debug-names", "--enable-all" );
|
|
execute( processBuilder );
|
|
assertTrue( wat2WasmFile.isFile() );
|
|
|
|
// create the node script
|
|
scriptFile = createScript( script, "nodetest.js", "{test}", script.name() );
|
|
}
|
|
return scriptFile;
|
|
}
|
|
|
|
/**
|
|
* Execute a external process and redirect the output to the console. Fire an JUnit fail if the process produce an error.
|
|
*
|
|
* @param processBuilder
|
|
* the process definition
|
|
* @throws Exception
|
|
* if any error occur
|
|
*/
|
|
private void execute( ProcessBuilder processBuilder ) throws Exception {
|
|
processBuilder.directory( getRoot() );
|
|
processBuilder.redirectOutput( Redirect.INHERIT );
|
|
processBuilder.redirectError( Redirect.INHERIT );
|
|
System.out.println( String.join( " ", processBuilder.command() ) );
|
|
Process process = processBuilder.start();
|
|
int exitCode = process.waitFor();
|
|
if( exitCode != 0 ) {
|
|
fail( readStream( process.getErrorStream(), false ) + "\nExit code: " + exitCode + " from: " + processBuilder.command().get( 0 ) );
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Load a script resource, patch it and save it
|
|
*
|
|
* @param script
|
|
* the script engine
|
|
* @param name
|
|
* the template resource name
|
|
* @param placeholder
|
|
* A placeholder that should be replaced.
|
|
* @param value
|
|
* the replacing value.
|
|
* @return The saved file name
|
|
* @throws IOException
|
|
* if any IO error occur
|
|
*/
|
|
private File createScript( ScriptEngine script, String name, String placeholder, String value ) throws IOException {
|
|
File file = newFile( script.name() + "Test.js" );
|
|
URL scriptUrl = getClass().getResource( name );
|
|
String template = readStream( scriptUrl.openStream(), true );
|
|
template = template.replace( placeholder, value );
|
|
try (FileOutputStream scriptStream = new FileOutputStream( file )) {
|
|
scriptStream.write( template.getBytes( StandardCharsets.UTF_8 ) );
|
|
}
|
|
return file;
|
|
}
|
|
|
|
/**
|
|
* Run a test single test. It run the method in Java and call it via node in the WenAssembly. If the result are
|
|
* different it fire an error.
|
|
*
|
|
* @param script
|
|
* The script engine
|
|
* @param methodName
|
|
* the method name of the test.
|
|
* @param params
|
|
* the parameters for the method
|
|
*/
|
|
public void test( ScriptEngine script, String methodName, Object... params ) {
|
|
Object expected;
|
|
try {
|
|
Class<?>[] types = new Class[params.length];
|
|
for( int i = 0; i < types.length; i++ ) {
|
|
Class<?> type = params[i].getClass();
|
|
switch( type.getName() ) {
|
|
case "java.lang.Byte":
|
|
type = byte.class;
|
|
break;
|
|
case "java.lang.Short":
|
|
type = short.class;
|
|
break;
|
|
case "java.lang.Character":
|
|
type = char.class;
|
|
break;
|
|
case "java.lang.Integer":
|
|
type = int.class;
|
|
break;
|
|
case "java.lang.Long":
|
|
type = long.class;
|
|
break;
|
|
case "java.lang.Float":
|
|
type = float.class;
|
|
break;
|
|
case "java.lang.Double":
|
|
type = double.class;
|
|
break;
|
|
}
|
|
types[i] = type;
|
|
}
|
|
Method method = null;
|
|
for( int i = 0; i < classes.length; i++ ) {
|
|
try {
|
|
Class<?> clazz = classes[i];
|
|
method = clazz.getDeclaredMethod( methodName, types );
|
|
break;
|
|
} catch( NoSuchMethodException ex ) {
|
|
if( i == classes.length - 1 ) {
|
|
throw ex;
|
|
}
|
|
}
|
|
}
|
|
method.setAccessible( true );
|
|
expected = method.invoke( null, params );
|
|
if( expected instanceof Character ) { // WASM does not support char that it is number
|
|
expected = new Integer( ((Character)expected).charValue() );
|
|
}
|
|
if( expected instanceof Boolean ) { // WASM does not support boolean that it is number
|
|
expected = new Integer( ((Boolean)expected) ? 1 : 0 );
|
|
}
|
|
|
|
Object actual;
|
|
String actualStr = evalWasm( script, methodName, params );
|
|
if( expected instanceof Double ) { // handle different string formating of double values
|
|
try {
|
|
actual = Double.valueOf( actualStr );
|
|
} catch( NumberFormatException ex ) {
|
|
actual = actualStr;
|
|
}
|
|
} else if( expected instanceof Float ) { // handle different string formating of float values
|
|
try {
|
|
actual = Float.valueOf( actualStr );
|
|
} catch( NumberFormatException ex ) {
|
|
actual = actualStr;
|
|
}
|
|
} else {
|
|
expected = String.valueOf( expected );
|
|
actual = actualStr;
|
|
}
|
|
assertEquals( expected, actual );
|
|
} catch( InvocationTargetException ex ) {
|
|
failed = true;
|
|
throwException( ex.getTargetException() );
|
|
} catch( Throwable ex ) {
|
|
failed = true;
|
|
throwException( ex );
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Compile the sources and create the ProcessBuilder
|
|
*
|
|
* @param script
|
|
* The script engine
|
|
* @return ProcessBuilder to execute the test
|
|
* @throws Exception
|
|
* if any error occur
|
|
*/
|
|
private ProcessBuilder createCommand( ScriptEngine script ) throws Exception {
|
|
compiler.setProperty( JWebAssembly.WASM_USE_GC, script.useGC );
|
|
switch( script ) {
|
|
case SpiderMonkey:
|
|
return spiderMonkeyCommand( true, script );
|
|
case SpiderMonkeyWat:
|
|
return spiderMonkeyCommand( false, script );
|
|
case SpiderMonkeyGC:
|
|
return spiderMonkeyCommand( true, script );
|
|
case SpiderMonkeyWatGC:
|
|
return spiderMonkeyCommand( false, script );
|
|
case NodeJS:
|
|
case NodeJsGC:
|
|
return nodeJsCommand( prepareNodeJs( script ) );
|
|
case NodeWat:
|
|
case NodeWatGC:
|
|
ProcessBuilder processBuilder = nodeJsCommand( prepareNodeWat( script ) );
|
|
processBuilder.environment().put( "NODE_PATH", getNodeModulePath() );
|
|
return processBuilder;
|
|
case Wat2Wasm:
|
|
case Wat2WasmGC:
|
|
return nodeJsCommand( prepareWat2Wasm( script ) );
|
|
default:
|
|
throw new IllegalStateException( script.toString() );
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Evaluate the wasm exported function.
|
|
*
|
|
* @param script
|
|
* The script engine
|
|
* @param methodName
|
|
* the method name of the test.
|
|
* @param params
|
|
* the parameters for the method
|
|
* @return the output of the script
|
|
*/
|
|
public String evalWasm( ScriptEngine script, String methodName, Object... params ) {
|
|
ProcessBuilder processBuilder = null;
|
|
try {
|
|
if( testData != null ) {
|
|
// data are available as block data
|
|
Map<String, String> resultMap = testResults.get( script );
|
|
if( resultMap != null ) {
|
|
return resultMap.get( methodName );
|
|
}
|
|
} else {
|
|
// block data then write single test data
|
|
writeJsonTestData( Collections.singletonMap( methodName, params ) );
|
|
}
|
|
|
|
processBuilder = createCommand( script );
|
|
processBuilder.directory( getRoot() );
|
|
Process process = processBuilder.start();
|
|
|
|
String stdoutMessage = "";
|
|
String errorMessage = "";
|
|
do {
|
|
if( process.getInputStream().available() > 0 ) {
|
|
stdoutMessage += readStream( process.getInputStream(), false );
|
|
}
|
|
if( process.getErrorStream().available() > 0 ) {
|
|
errorMessage += readStream( process.getErrorStream(), false );
|
|
}
|
|
}
|
|
while( !process.waitFor( 10, TimeUnit.MILLISECONDS ) );
|
|
stdoutMessage += readStream( process.getInputStream(), false );
|
|
errorMessage += readStream( process.getErrorStream(), false );
|
|
int exitCode = process.exitValue();
|
|
|
|
// read the result from file
|
|
File resultFile = new File( getRoot(), "testresult.json" );
|
|
String result = null;
|
|
if( resultFile.exists() ) {
|
|
try( InputStreamReader jsonData = new InputStreamReader( new FileInputStream( new File( getRoot(), "testresult.json" ) ), StandardCharsets.UTF_8 ) ) {
|
|
@SuppressWarnings( "unchecked" )
|
|
Map<String, String> map = new Gson().fromJson( jsonData, Map.class );
|
|
if( testData != null ) {
|
|
testResults.put( script, map );
|
|
}
|
|
result = map.get( methodName );
|
|
}
|
|
}
|
|
|
|
if( exitCode != 0 || !stdoutMessage.isEmpty() || !errorMessage.isEmpty() ) {
|
|
System.err.println( stdoutMessage );
|
|
System.err.println( errorMessage );
|
|
fail( stdoutMessage + '\n' + errorMessage + '\n' + result + "\nExit code: " + exitCode );
|
|
}
|
|
|
|
return result;
|
|
} catch( Throwable ex ) {
|
|
failed = true;
|
|
ex.printStackTrace();
|
|
|
|
if( processBuilder != null ) {
|
|
String executable = processBuilder.command().get( 0 );
|
|
System.err.println( executable );
|
|
File exec = new File(executable);
|
|
System.err.println( exec.exists() );
|
|
exec = exec.getParentFile();
|
|
if( exec != null ) {
|
|
System.err.println( Arrays.toString( exec.list() ) );
|
|
}
|
|
}
|
|
|
|
throwException( ex );
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Create a ProcessBuilder for spider monkey script shell.
|
|
*
|
|
* @param binary
|
|
* true, if the WASM format should be test; false, if the WAT format should be tested.
|
|
* @param script
|
|
* the script engine
|
|
* @return the value from the script
|
|
* @throws IOException
|
|
* if the download failed
|
|
*/
|
|
private ProcessBuilder spiderMonkeyCommand( boolean binary, ScriptEngine script ) throws IOException {
|
|
boolean gc = Boolean.valueOf( script.useGC );
|
|
File scriptFile = scriptFiles.get( script );
|
|
if( scriptFile == null ) {
|
|
File file = compile( script );
|
|
if( gc ) {
|
|
if( binary ) {
|
|
scriptFile = createScript( script, "SpiderMonkeyTest.js", "{test.wasm}", file.getName() );
|
|
} else {
|
|
scriptFile = createScript( script, "SpiderMonkeyWatTest.js", "{test}", script.name() );
|
|
}
|
|
} else {
|
|
if( binary ) {
|
|
scriptFile = createScript( script, "SpiderMonkeyTest.js", "{test.wasm}", file.getName() );
|
|
} else {
|
|
scriptFile = createScript( script, "SpiderMonkeyWatTest.js", "{test}", script.name() );
|
|
}
|
|
}
|
|
scriptFiles.put( script, scriptFile );
|
|
}
|
|
|
|
ProcessBuilder process = new ProcessBuilder( spiderMonkey.getCommand(), scriptFile.getAbsolutePath() );
|
|
if( gc ) {
|
|
process.command().add( 1, "--wasm-gc" );
|
|
}
|
|
return process;
|
|
}
|
|
|
|
/**
|
|
* The executable of the node command.
|
|
*
|
|
* @return the node executable
|
|
* @throws IOException
|
|
* if any I/O error occur
|
|
*/
|
|
@Nonnull
|
|
private static String nodeExecuable() throws IOException {
|
|
String command = node.getNodeDir();
|
|
if( command == null ) {
|
|
command = "node";
|
|
} else {
|
|
if( IS_WINDOWS ) {
|
|
command += "/node";
|
|
} else {
|
|
command += "/bin/node";
|
|
}
|
|
}
|
|
return command;
|
|
}
|
|
|
|
/**
|
|
* Create a ProcessBuilder for node.js
|
|
*
|
|
* @param nodeScript
|
|
* the path to the script that should be executed
|
|
* @return the value from the script
|
|
* @throws IOException
|
|
* if any I/O error occur
|
|
*/
|
|
private static ProcessBuilder nodeJsCommand( File nodeScript ) throws IOException {
|
|
String command = nodeExecuable();
|
|
// details see with command: node --v8-options
|
|
ProcessBuilder processBuilder = new ProcessBuilder( command, //
|
|
"--experimental-wasm-eh", // exception handling
|
|
"--experimental-wasm-typed-funcref", //
|
|
"--experimental-wasm-gc", //
|
|
nodeScript.getName() );
|
|
if( IS_WINDOWS ) {
|
|
processBuilder.command().add( 0, "cmd" );
|
|
processBuilder.command().add( 1, "/C" );
|
|
}
|
|
return processBuilder;
|
|
}
|
|
|
|
/**
|
|
* Reads a stream into a String.
|
|
*
|
|
* @param input
|
|
* the InputStream
|
|
* @return the string
|
|
* @throws IOException
|
|
* if an I/O error occurs.
|
|
*/
|
|
@SuppressWarnings( "resource" )
|
|
public static String readStream( InputStream input, boolean all ) throws IOException {
|
|
byte[] bytes = new byte[8192];
|
|
ByteArrayOutputStream stream = new ByteArrayOutputStream();
|
|
int count;
|
|
while( (all || input.available() > 0) && (count = input.read( bytes )) > 0 ) {
|
|
stream.write( bytes, 0, count );
|
|
}
|
|
return new String( stream.toByteArray() );
|
|
}
|
|
|
|
/**
|
|
* Throw any exception independent of signatures
|
|
*
|
|
* @param exception
|
|
* the exception
|
|
* @throws T
|
|
* a generic helper
|
|
*/
|
|
@SuppressWarnings( "unchecked" )
|
|
public static <T extends Throwable> void throwException( Throwable exception ) throws T {
|
|
throw (T)exception;
|
|
}
|
|
}
|