Java 类java.io.Writer 实例源码

private boolean process() throws IOException {
    boolean toReturn = false;
    PDFTextStripper stripper = new TitleExtractor();
    PDDocument document = null;

    try {
        document = PDDocument.load(new File(this.getFileNamePathWithExtension()));

        //((TitleExtractor) stripper).setFileNamePathWithExtension(this.getFileNamePathWithExtension());
        stripper.setSortByPosition(true);
        stripper.setStartPage(0);
        stripper.setEndPage(1);

        Writer dummy = new OutputStreamWriter(new ByteArrayOutputStream());
        stripper.writeText(document, dummy);

        setTitle(((TitleExtractor) stripper).getTitle());

        toReturn = true;
    } finally {
        if (document != null) {
            document.close();
        }
    }
    return toReturn;
}

/** Emit a class file for a given class.
 *  @param c      The class from which a class file is generated.
 */
public FileObject write(ClassSymbol c)
    throws IOException
{
    String className = c.flatName().toString();
    FileObject outFile
        = fileManager.getFileForOutput(StandardLocation.NATIVE_HEADER_OUTPUT,
            "", className.replaceAll("[.$]", "_") + ".h", null);
    Writer out = outFile.openWriter();
    try {
        write(out, c);
        if (verbose)
            log.printVerbose("wrote.file", outFile);
        out.close();
        out = null;
    } finally {
        if (out != null) {
            // if we are propogating an exception, delete the file
            out.close();
            outFile.delete();
            outFile = null;
        }
    }
    return outFile; // may be null if write failed
}

/**
 * Schrijf dit attribuut.
 *
 * @param value waarde
 * @param writer writer om XML mee te schrijven
 * @throws EncodeException bij encodeer foute
 */
@Override
public void encode(final Context context, final T value, final Writer writer) throws EncodeException {
    LOGGER.debug("encode(value={})", value);
    if (value == null) {
        return;
    }

    try {
        writer.append(" ");
        writer.append(getName());
        writer.append("=\"");
        writer.append(converter.encode(context, value));
        writer.append("\"");
    } catch (final IOException e) {
        throw new EncodeException(context.getElementStack(), e);
    }
}

public void writeChanges() throws IOException
{
    Collection<V> collection = this.values.values();
    String s = this.gson.toJson((Object)collection);
    BufferedWriter bufferedwriter = null;

    try
    {
        bufferedwriter = Files.newWriter(this.saveFile, Charsets.UTF_8);
        bufferedwriter.write(s);
    }
    finally
    {
        IOUtils.closeQuietly((Writer)bufferedwriter);
    }
}

public static void writeCData(String val, Writer w) throws IOException {
    String begCData = "<![CDATA[";
    String endCData = "]]>";
    w.write(begCData);
    for (int vpos = 0, split;; vpos = split) {
        split = val.indexOf(endCData, vpos);
        if (split < 0) {
            w.write(val, vpos, val.length() - vpos);
            w.write(endCData);
            return;
        }
        split += 2; // bisect the "]]>" goo
        w.write(val, vpos, split - vpos);
        w.write(endCData);
        w.write(begCData);
    }
}

/**
 * 导入配置信息【目前支持baseTaskType和strategy数据】
 * 
 * @param config
 * @param writer
 * @param isUpdate
 * @throws Exception
 */
public void importConfig(String config, Writer writer, boolean isUpdate)
        throws Exception {
    ConfigNode configNode = gson.fromJson(config, ConfigNode.class);
    if (configNode != null) {
        String path = configNode.getRootPath() + "/"
                + configNode.getConfigType();
        ZKTools.createPath(getZooKeeper(), path, CreateMode.PERSISTENT, zkManager.getAcl());
        String y_node = path + "/" + configNode.getName();
        if (getZooKeeper().exists(y_node, false) == null) {
            writer.append("<font color=\"red\">成功导入新配置信息\n</font>");
            getZooKeeper().create(y_node, configNode.getValue().getBytes(),
                    zkManager.getAcl(), CreateMode.PERSISTENT);
        } else if (isUpdate) {
            writer.append("<font color=\"red\">该配置信息已经存在，并且强制更新了\n</font>");
            getZooKeeper().setData(y_node,
                    configNode.getValue().getBytes(), -1);
        } else {
            writer.append("<font color=\"red\">该配置信息已经存在，如果需要更新，请配置强制更新\n</font>");
        }
    }
    writer.append(configNode.toString());
}

@Test
public void testDate() throws ParseException, PebbleException, IOException {
    PebbleEngine pebble = new PebbleEngine.Builder().loader(new StringLoader()).strictVariables(false)
            .defaultLocale(Locale.ENGLISH).build();

    String source = "{{ realDate | date('MM/dd/yyyy') }}{{ realDate | date(format) }}{{ stringDate | date('yyyy/MMMM/d','yyyy-MMMM-d') }}";

    PebbleTemplate template = pebble.getTemplate(source);
    Map<String, Object> context = new HashMap<>();
    DateFormat format = new SimpleDateFormat("yyyy-MMMM-d", Locale.ENGLISH);
    Date realDate = format.parse("2012-July-01");
    context.put("realDate", realDate);
    context.put("stringDate", format.format(realDate));
    context.put("format", "yyyy-MMMM-d");

    Writer writer = new StringWriter();
    template.evaluate(writer, context);
    assertEquals("07/01/20122012-July-12012/July/1", writer.toString());
}

/**
 * Tests if the macro output SafeString concatenation is working.
 */
@Test
public void testMacroSafeStringConcatenation() throws PebbleException, IOException {

    PebbleEngine pebble = new PebbleEngine.Builder().loader(new StringLoader()).strictVariables(false).build();

    String source = "{% macro macro1() %}Bob{% endmacro %}\n"
                  + "{% macro macro2() %}Maria{% endmacro %}\n"
                  + "{% macro macro3() %}John{% endmacro %}\n"
                  + "{{ (macro1() + macro2() + macro3()) | lower }}";
    PebbleTemplate template = pebble.getTemplate(source);

    Map<String, Object> context = new HashMap<>();

    Writer writer = new StringWriter();
    template.evaluate(writer, context);
    assertEquals("bobmariajohn", writer.toString());

}

/**
 * Start the transfer manifest
 */
public void startTransferManifest(Writer writer) throws SAXException
{
    format = OutputFormat.createPrettyPrint();
    format.setNewLineAfterDeclaration(false);
    format.setIndentSize(3);
    format.setEncoding("UTF-8");

    this.writer = new XMLWriter(writer, format);
    this.writer.startDocument();

    this.writer.startPrefixMapping(PREFIX, TransferModel.TRANSFER_MODEL_1_0_URI);
    this.writer.startPrefixMapping("cm", NamespaceService.CONTENT_MODEL_1_0_URI);

    // Start Transfer Manifest // uri, name, prefix
    this.writer.startElement(TransferModel.TRANSFER_MODEL_1_0_URI,
                ManifestModel.LOCALNAME_TRANSFER_MAINIFEST, PREFIX + ":"
                            + ManifestModel.LOCALNAME_TRANSFER_MAINIFEST, EMPTY_ATTRIBUTES);
}

public void writeAnnotations(Writer out) throws IOException {
    List<MapItem> mapItems = dexFile.getMapItems();
    // sort the map items based on the order defined by sectionAnnotationOrder
    Ordering<MapItem> ordering = Ordering.from(new Comparator<MapItem>() {
        @Override public int compare(MapItem o1, MapItem o2) {
            return Ints.compare(sectionAnnotationOrder.get(o1.getType()), sectionAnnotationOrder.get(o2.getType()));
        }
    });

    mapItems = ordering.immutableSortedCopy(mapItems);

    try {
        for (MapItem mapItem: mapItems) {
            SectionAnnotator annotator = annotators.get(mapItem.getType());
            annotator.annotateSection(this);
        }
    } finally {
        dexFile.writeAnnotations(out, this);
    }
}

@Override
public Writer run(Writer writer, List<Object> scopes) {
    if (getCodes() != null) {
        for (Code code : getCodes()) {
            try (StringWriter capture = new StringWriter()) {
                code.execute(capture, scopes);

                String s = capture.toString();
                if (s != null) {
                    encoder.encode(s, writer);
                }
            } catch (IOException e) {
                throw new MustacheException("Exception while parsing mustache function at line " + tc.line(), e);
            }
        }
    }
    return writer;
}

/**
 * Dump out a VoltTable as a CSV to the given writer
 * If the header flag is set to true, then the output will include 
 * the column names in the first row
 * @param out
 * @param vt
 * @param write_header
 */
public static void csv(Writer out, VoltTable vt, boolean header) {
    CSVWriter writer = new CSVWriter(out);

    if (header) {
        String cols[] = new String[vt.getColumnCount()];
        for (int i = 0; i < cols.length; i++) {
            cols[i] = vt.getColumnName(i);
        } // FOR
        writer.writeNext(cols);
    }
    vt.resetRowPosition();
    while (vt.advanceRow()) {
        String row[] = vt.getRowStringArray();
        assert(row != null);
        assert(row.length == vt.getColumnCount());
        writer.writeNext(row);
    } // WHILE
}

private void setupJavaTemplates() throws Exception {
    testFile = new File(getWorkDir(), "Test.java");
    TestUtilities.copyStringToFile(testFile,
        "package zoo;\n" +
        "\n" +
        "public class A {\n" +
        "}\n"
    );

    FileObject emptyJava = FileUtil.createData(FileUtil.getConfigRoot(), "Templates/Classes/Empty.java");
    emptyJava.setAttribute("template", Boolean.TRUE);
    classJava = FileUtil.createData(FileUtil.getConfigRoot(), "Templates/Classes/Class.java");
    classJava.setAttribute("template", Boolean.TRUE);
    classJava.setAttribute("verbatim-create-from-template", Boolean.TRUE);
    template = "/*\r\ninitial\r\ncomment\r\n*/\r\npackage zoo;\r\npublic class Template {\r\n    public Template() {}\r\n}\r\n";
    Writer w = new OutputStreamWriter(classJava.getOutputStream(), "UTF-8");
    w.write(template);
    w.close();
}

public void onCargoInspected(@Observes @CargoInspected Cargo cargo) {
    Writer writer = new StringWriter();

    try (JsonGenerator generator = Json.createGenerator(writer)) {
        generator
                .writeStartObject()
                .write("trackingId", cargo.getTrackingId().getIdString())
                .write("origin", cargo.getOrigin().getName())
                .write("destination", cargo.getRouteSpecification().getDestination().getName())
                .write("lastKnownLocation", cargo.getDelivery().getLastKnownLocation().getName())
                .write("transportStatus", cargo.getDelivery().getTransportStatus().toString())
                .writeEnd();
    }

    String jsonValue = writer.toString();

    for (Session session : sessions) {
        try {
            session.getBasicRemote().sendText(jsonValue);
        } catch (IOException ex) {
            logger.log(Level.WARNING, "Unable to publish WebSocket message", ex);
        }
    }

}

/** store the setting object even if was not changed */
private void writeDown() throws IOException {
    Object inst = instance.get();
    if (inst == null) return ;

    ByteArrayOutputStream b = new ByteArrayOutputStream(1024);
    Writer w = new OutputStreamWriter(b, "UTF-8"); // NOI18N
    try {
        isWriting = true;
        Convertor conv = getConvertor();
        if (conv != null) {
            conv.write(w, inst);
        } else {
            write(w, inst);
        }
    } finally {
        w.close();
        isWriting = false;
    }
    isChanged = false;

    buf = b;
    file.getFileSystem().runAtomicAction(this);
    buf = null;
    if (!isChanged) firePropertyChange(PROP_SAVE);
}

static void save (final FileObject fo, final String content) {
    requestProcessor.post (new Runnable () {
        public void run () {
            try {
                FileLock lock = fo.lock ();
                try {
                    OutputStream os = fo.getOutputStream (lock);
                    Writer writer = new OutputStreamWriter (os, "UTF-8"); // NOI18N
                    try {
                        writer.write (content);
                    } finally {
                        writer.close ();
                    } 
                } finally {
                    lock.releaseLock ();
                }
            } catch (IOException ex) {
                ErrorManager.getDefault ().notify (ex);
            }
        }
    });
}

@Test
public void testSetCharacterStream() throws Exception {
    FileBackedClob b;
    char[] test1 = "test".toCharArray();
    char[] test2 = "test0123456789".toCharArray();
    char[] firstPartReference = new char[testCase2.length - test1.length - 4];
    char[] secondPartReference = new char[4];
    System.arraycopy(testCase2, 0, firstPartReference, 0, testCase2.length - test1.length - 4);
    System.arraycopy(testCase2, testCase2.length - 4 - 1, secondPartReference, 0, 4);
    b = new FileBackedClob(new CharArrayReader(testCase2));
    Writer os = b.setCharacterStream(testCase2.length - test1.length - 4 + 1);
    os.write(test1);
    os.close();
    assertEquals(new String(firstPartReference), b.getSubString(1, testCase2.length - test1.length - 4));
    assertEquals(new String(secondPartReference), b.getSubString(testCase2.length - 4, 4));
    assertEquals(new String(test1), b.getSubString(testCase2.length - 4 - test1.length + 1, test1.length));
    assertEquals(b.length(), 1024);
    os = b.setCharacterStream(testCase2.length - test1.length - 4 + 1);
    os.write(test2);
    os.close();
    assertEquals(new String(firstPartReference), b.getSubString(1, testCase2.length - test1.length - 4));
    assertEquals(b.length(), 1024 - test1.length - 4 + test2.length);
    assertEquals(new String(test2), b.getSubString(b.length() - test2.length + 1, test2.length));
    b.free();
}

/**
 * Transpile the given resource to the given writers.
 *
 * @param resource
 *            the resource to transpile.
 * @param options
 *            the {@link GeneratorOption generator options} to use during generation.
 * @param outCode
 *            the writer where the generated output code should be sent.
 * @param optSourceMapInfo
 *            meta-info including the writer to create source-maps. If absent do not create source-maps.
 */
public void transpile(N4JSResource resource, GeneratorOption[] options, Writer outCode,
        Optional<SourceMapInfo> optSourceMapInfo) {

    // step 1: create initial transpiler state (i.e. create intermediate model, etc.)
    final TranspilerState state = prepare(resource, options);

    // step 2: execute all transformations on the transpiler state
    transform(state);

    // step 3: pretty-print the intermediate model + emit source maps (optional)
    final Optional<String> optPreamble = getPreamble();
    prettyPrint(state, outCode, optPreamble, optSourceMapInfo);
}

@Test
public void testBinaryOperators() throws PebbleException, IOException {
    PebbleEngine pebble = new PebbleEngine.Builder().loader(new StringLoader()).strictVariables(false).build();

    String source = "{{ 8 + 5 * 4 - (6 + 10 / 2)  + 44 }}-{{ 10%3 }}";
    PebbleTemplate template = pebble.getTemplate(source);

    Writer writer = new StringWriter();
    template.evaluate(writer);
    assertEquals("61-1", writer.toString());
}

/**
 * Send the content to an output stream.
 *
 * @param out the output stream
 * @param triples the triples
 * @param subject the subject
 */
public void write(final OutputStream out, final Stream<? extends Triple> triples, final IRI subject) {
    final Writer writer = new OutputStreamWriter(out, UTF_8);
    try {
        template
            .execute(writer, new HtmlData(namespaceService, subject, triples.collect(toList()), properties))
            .flush();
    } catch (final IOException ex) {
        throw new UncheckedIOException(ex);
    }
}

@Test
public void testExpressionInArguments() throws PebbleException, IOException {
    PebbleEngine pebble = new PebbleEngine.Builder().loader(new StringLoader()).strictVariables(false).build();

    PebbleTemplate template = pebble
            .getTemplate("{{ input(1 + 1) }}{% macro input(value) %}{{value}}{% endmacro %}");

    Writer writer = new StringWriter();
    template.evaluate(writer);
    assertEquals("2", writer.toString());
}

@Test
public void testRawFilterWithJsonObject() throws PebbleException, IOException {
    PebbleEngine pebble = new PebbleEngine.Builder().loader(new StringLoader()).strictVariables(false).build();
    PebbleTemplate template = pebble.getTemplate("{{ text | raw }}");
    Map<String, Object> context = new HashMap<>();
    context.put("text", new JsonObject());
    Writer writer = new StringWriter();
    template.evaluate(writer, context);
    assertEquals(JsonObject.JSON_VALUE, writer.toString());
}

public static String prettyPrintXML(final String xml) {
    final Reader reader = new StringReader(xml);
    final Writer writer = new StringWriter(1000);

    prettyPrintXML(reader, writer);

    return writer.toString();
}

/**
 * Open an writer for the file, using the encoding (if any) given in the
 * doclet configuration.
 * The file must have been created with a location of
 * {@link DocumentationTool.Location#DOCUMENTATION_OUTPUT} and a corresponding relative path.
 */
public Writer openWriter() throws IOException, UnsupportedEncodingException {
    if (location != DocumentationTool.Location.DOCUMENTATION_OUTPUT)
        throw new IllegalStateException();

    createDirectoryForFile(file);
    FileOutputStream fos = new FileOutputStream(file);
    if (configuration.docencoding == null) {
        return new BufferedWriter(new OutputStreamWriter(fos));
    } else {
        return new BufferedWriter(new OutputStreamWriter(fos, configuration.docencoding));
    }
}

@Override
public HierarchicalStreamWriter createWriter(final Writer out) {
    final HierarchicalStreamWriter[] writer = new HierarchicalStreamWriter[1];
    final FilterWriter filter = new FilterWriter(out) {
        @Override
        public void close() {
            writer[0].close();
        }
    };
    writer[0] = new Dom4JXmlWriter(new XMLWriter(filter, outputFormat), getNameCoder());
    return writer[0];
}

protected void testFlows(String flowsContent, boolean verbose) throws IOException {
    Writer writer = new StringWriter();
    TableFormatterConfig config = new TableFormatterConfig(Locale.getDefault(), ';', "inv", true, true);
    try (ValidationWriter flowsWriter = getFlowsValidationFormatterCsvWriter(config, writer, verbose)) {
        flowsWriter.write(branchId, p1, p1Calc, q1, q1Calc, p2, p2Calc, q2, q2Calc, r, x, g1, g2, b1, b2, rho1, rho2,
                          alpha1, alpha2, u1, u2, theta1, theta2, z, y, ksi, connected1, connected2, mainComponent1,
                          mainComponent2, validated);
        assertEquals(flowsContent, writer.toString().trim());
    }
}

/**
 * Make a fresh JSONWriter. It can be used to build one JSON text.
 */
public JSONWriter(Writer w) {
    this.comma = false;
    this.mode = 'i';
    this.stack = new JSONObject[maxdepth];
    this.top = 0;
    this.writer = w;
}

/**
 * Write out the QPP to a file.
 *
 * @param jsonWrapper The QPP to write
 * @param outFile The location to write.
 */
private void writeOutQpp(JsonWrapper jsonWrapper, Path outFile) {
    try (Writer writer = Files.newBufferedWriter(outFile)) {
        writer.write(jsonWrapper.toString());
        writer.flush();
    } catch (IOException exception) {
        DEV_LOG.error("Could not write out QPP JSON to file", exception);
    }
}

/**
 * Converts the data in the given netcdf file to text format and returns this as a String.
 * This can be used e.g. in unit tests to compare the data in human readable text format instead of in binary format.
 *
 * @param netcdfFile netcdf file
 * @param variableNames semicolon delimited list of variables of which the data should be printed.
 *                      If this is null or empty, then all variables are printed.
 * @return String with cdl representation of the data.
 * @throws IOException
 */
public static String netcdfFileToString(File netcdfFile, String variableNames) throws IOException {
    boolean printAllVariables = false;
    if (variableNames == null || variableNames.isEmpty()) {
        printAllVariables = true;
        variableNames = null;
    }

    Writer writer = new StringWriter();
    NCdumpW.print(netcdfFile.getAbsolutePath(), writer, printAllVariables, false, false, true, variableNames, null);
    return writer.toString();
}

@Test
public void testMultiLevelInheritance() throws PebbleException, IOException {
    PebbleEngine pebble = new PebbleEngine.Builder().strictVariables(false).build();
    PebbleTemplate template = pebble.getTemplate("templates/template.child.peb");

    Writer writer = new StringWriter();
    template.evaluate(writer);
    assertEquals("GRANDFATHER TEXT ABOVE HEAD" + LINE_SEPARATOR + LINE_SEPARATOR + "\tCHILD HEAD" + LINE_SEPARATOR
            + LINE_SEPARATOR + "GRANDFATHER TEXT BELOW HEAD AND ABOVE FOOT" + LINE_SEPARATOR + LINE_SEPARATOR + "\tGRANDFATHER FOOT" + LINE_SEPARATOR + LINE_SEPARATOR
            + "GRANDFATHER TEXT BELOW FOOT", writer.toString());
}

/**
 * Handle one of the default entities, return false if it
 * is not a default entity.
 *
 * @param ch character to be escaped.
 * @param i index into character array.
 * @param chars non-null reference to character array.
 * @param len length of chars.
 * @param fromTextNode true if the characters being processed
 * are from a text node, false if they are from an attribute value
 * @param escLF true if the linefeed should be escaped.
 *
 * @return i+1 if the character was written, else i.
 *
 * @throws java.io.IOException
 */
protected int accumDefaultEntity(
    java.io.Writer writer,
    char ch,
    int i,
    char[] chars,
    int len,
    boolean fromTextNode,
    boolean escLF)
    throws IOException
{

    if (!escLF && CharInfo.S_LINEFEED == ch)
    {
        writer.write(m_lineSep, 0, m_lineSepLen);
    }
    else
    {
        // if this is text node character and a special one of those,
        // or if this is a character from attribute value and a special one of those
        if ((fromTextNode && m_charInfo.isSpecialTextChar(ch)) || (!fromTextNode && m_charInfo.isSpecialAttrChar(ch)))
        {
            String outputStringForChar = m_charInfo.getOutputStringForChar(ch);

            if (null != outputStringForChar)
            {
                writer.write(outputStringForChar);
            }
            else
                return i;
        }
        else
            return i;
    }

    return i + 1;

}

public void testNullWriter() throws Exception {
  // create a null writer
  Writer nullWriter = CharStreams.nullWriter();
  // write to the writer
  nullWriter.write('n');
  String test = "Test string for NullWriter";
  nullWriter.write(test);
  nullWriter.write(test, 2, 10);
  // nothing really to assert?
  assertSame(CharStreams.nullWriter(), CharStreams.nullWriter());
}

@Override
public void execute(Template.Fragment frag, Writer out) throws IOException {
    String body = frag.execute();
    if (body.equals(((Map) frag.context()).get(NavNameLambda.NAME))) {
        out.write(ACTIVE_CLASS_NAME);
    }
}

public void testAsWriter() {
  // Should wrap Appendable in a new object
  Appendable plainAppendable = new StringBuilder();
  Writer result = CharStreams.asWriter(plainAppendable);
  assertNotSame(plainAppendable, result);
  assertNotNull(result);

  // A Writer should not be wrapped
  Appendable secretlyAWriter = new StringWriter();
  result = CharStreams.asWriter(secretlyAWriter);
  assertSame(secretlyAWriter, result);
}

String getPage(String filename, Map<String, Object> data) throws IOException {
    try (Writer stream = new StringWriter();) {
        Template template = configuration.getTemplate(filename);
        template.process(data, stream);
        return stream.toString();
    } catch (TemplateException e) {
        throw new IOException(e);
    }
}

void realClasses(String location, Predicate<String> acceptor, Writer output, String version) throws Exception {
    Path classes = Paths.get(location);
    Map<String, JavaFileObject> className2File = new HashMap<>();
    Map<JavaFileObject, String> file2ClassName = new HashMap<>();

    try (BufferedReader descIn = Files.newBufferedReader(classes)) {
        String classFileData;

        while ((classFileData = descIn.readLine()) != null) {
            ByteArrayOutputStream data = new ByteArrayOutputStream();
            for (int i = 0; i < classFileData.length(); i += 2) {
                data.write(Integer.parseInt(classFileData.substring(i, i + 2), 16));
            }
            JavaFileObject file = new ByteArrayJavaFileObject(data.toByteArray());
            try (InputStream in = new ByteArrayInputStream(data.toByteArray())) {
                String name = ClassFile.read(in).getName().replace("/", ".");
                className2File.put(name, file);
                file2ClassName.put(file, name);
            } catch (IOException | ConstantPoolException ex) {
                throw new IllegalStateException(ex);
            }
        }
    }

    try (JavaFileManager fm = new TestFileManager(className2File, file2ClassName)) {
        JavacTaskImpl task = (JavacTaskImpl) ToolProvider.getSystemJavaCompiler().getTask(null, fm, null, Arrays.asList("-source", version), null, Arrays.asList(new ToolBox.JavaSource("Test", "")));
        task.parse();

        PACK: for (String pack : packages(fm)) {
            PackageElement packEl = task.getElements().getPackageElement(pack);
            assert packEl != null;
            new ExhaustiveElementScanner(task, output, acceptor).visit(packEl);
        }
    }
}

private void writeLinesFrom(Iterable<String> services) throws IOException {
  new CharSink() {
    @Override
    public Writer openStream() throws IOException {
      return getFiler()
          .createResource(StandardLocation.CLASS_OUTPUT, key.packageName, key.relativeName)
          .openWriter();
    }
  }.writeLines(services, "\n");
}

static void writeTsv(ImmutableMultiset<String> data, File file) throws IOException {
  try (Writer out = Files.asCharSink(file, Charsets.UTF_8).openBufferedStream()) {
    for (Entry<String> e : Multisets.copyHighestCountFirst(data).entrySet()) {
      out.write(e.getElement() + "\t" + e.getCount() + "\n");
    }
  }
}

private void encryptedShuffleWithCerts(boolean useClientCerts)
  throws Exception {
  try {
    Configuration conf = new Configuration();
    String keystoresDir = new File(BASEDIR).getAbsolutePath();
    String sslConfsDir =
      KeyStoreTestUtil.getClasspathDir(TestEncryptedShuffle.class);
    KeyStoreTestUtil.setupSSLConfig(keystoresDir, sslConfsDir, conf,
                                    useClientCerts);
    conf.setBoolean(MRConfig.SHUFFLE_SSL_ENABLED_KEY, true);
    startCluster(conf);
    FileSystem fs = FileSystem.get(getJobConf());
    Path inputDir = new Path("input");
    fs.mkdirs(inputDir);
    Writer writer =
      new OutputStreamWriter(fs.create(new Path(inputDir, "data.txt")));
    writer.write("hello");
    writer.close();

    Path outputDir = new Path("output", "output");

    JobConf jobConf = new JobConf(getJobConf());
    jobConf.setInt("mapred.map.tasks", 1);
    jobConf.setInt("mapred.map.max.attempts", 1);
    jobConf.setInt("mapred.reduce.max.attempts", 1);
    jobConf.set("mapred.input.dir", inputDir.toString());
    jobConf.set("mapred.output.dir", outputDir.toString());
    JobClient jobClient = new JobClient(jobConf);
    RunningJob runJob = jobClient.submitJob(jobConf);
    runJob.waitForCompletion();
    Assert.assertTrue(runJob.isComplete());
    Assert.assertTrue(runJob.isSuccessful());
  } finally {
    stopCluster();
  }
}

/**
 * Returns a writer for this encoding based on
 * an output stream.
 *
 * @return A suitable writer
 * @exception UnsupportedEncodingException There is no convertor
 *  to support this encoding
 */
public Writer getWriter(OutputStream output)
    throws UnsupportedEncodingException {
    // this should always be true!
    if (javaName != null)
        return new OutputStreamWriter(output, javaName);
    javaName = EncodingMap.getIANA2JavaMapping(ianaName);
    if(javaName == null)
        // use UTF-8 as preferred encoding
        return new OutputStreamWriter(output, "UTF8");
    return new OutputStreamWriter(output, javaName);
}