final ProcessEnvironment processEnvironment = Mock()
    final GlobalUserInputReceiver userInput = Stub()
    final DaemonClient client = new DaemonClient(connector, outputEventListener, compatibilitySpec, new ByteArrayInputStream(new byte[0]), userInput, idGenerator, processEnvironment)

    def "executes action"() {
        def resultMessage = Stub(BuildActionResult)

        when:

    }

    def "standard input is passed on to executor"() {
        given:
        def standardInput = new ByteArrayInputStream()
        def gradleUserHomeDir = testDirectoryProvider.createDir('some/dir')

        when:
        createRunnerWithWorkingDirAndArgument()
            .withStandardInput(standardInput)
            .build()

import com.google.common.reflect.ClassPath.ClassInfo;
import com.google.common.reflect.ClassPath.ResourceInfo;
import com.google.common.testing.EqualsTester;
import com.google.common.testing.NullPointerTester;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.FilePermission;
import java.io.IOException;
import java.io.InputStream;
import java.net.MalformedURLException;

        encoder.flush()
    }

    Isolatable<?>[] deserialize() {
        def isolatables = []
        def decoder = new KryoBackedDecoder(new ByteArrayInputStream(outputStream.toByteArray()));
        int size = decoder.readInt()
        size.times {
            isolatables.add(serializer.readIsolatable(decoder))
        }
        return isolatables as Isolatable<?>[]

import assertk.assertions.containsExactly
import assertk.assertions.isEqualTo
import assertk.assertions.isFalse
import assertk.assertions.isInstanceOf
import assertk.assertions.isTrue
import java.io.ByteArrayInputStream
import java.security.cert.CertificateFactory
import java.security.cert.X509Certificate
import javax.net.ssl.SSLSession
import javax.security.auth.x500.X500Principal
import okhttp3.FakeSSLSession

            concurrent.start {
                withConnectionInDir("build$idx") { connection ->
                    def model = connection.model(GradleProject.class)
                    model.standardInput = new ByteArrayInputStream("project $idx".toString().bytes)
                    def project = model.get()
                    assert project.description == "project $idx"
                }
            }
        }

    }

    private void looksLike(String expected, byte[] actual) {
        DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(new ByteArrayInputStream(actual))
        assert removeTrailingWhitespace(new String(actual, "utf-8")) == removeTrailingWhitespace(TextUtil.toPlatformLineSeparators("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + expected))
    }

 * either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.crawler.extractor.impl;

import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.util.HashMap;
import java.util.Map;

import org.codelibs.core.io.CloseableUtil;
import org.codelibs.core.io.ResourceUtil;

    }

    abstract void decodeFrom(InputStream inputStream, Closure<Decoder> closure)

    void decode(byte[] bytes, Closure<Decoder> closure) {
        decodeFrom(new ByteArrayInputStream(bytes), closure)
    }

            <T> T withInputStream(IoFunction<InputStream, T> action) throws IOException {
                if (exception) {
                    throw exception
                }
                return action.apply(new ByteArrayInputStream(bos.toByteArray()))
            }

            @Override
            int size() {
                return bos.size()
            }

            @Override
            boolean canReopen() {