下面列出了java.io.ByteArrayOutputStream#toString ( ) 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
@Test
public void testIntercept_ShouldEncryptRequestPayloadAndUpdateContentLengthHeader() throws Exception {
// GIVEN
FieldLevelEncryptionConfig config = getTestFieldLevelEncryptionConfigBuilder()
.withEncryptionPath("$.foo", "$.encryptedFoo")
.build();
HttpRequest request = mock(HttpRequest.class);
HttpHeaders httpHeaders = new HttpHeaders();
when(request.getContent()).thenReturn(new ByteArrayContent(JSON_TYPE, "{\"foo\":\"bar\"}".getBytes()));
when(request.getHeaders()).thenReturn(httpHeaders);
// WHEN
HttpExecuteFieldLevelEncryptionInterceptor instanceUnderTest = new HttpExecuteFieldLevelEncryptionInterceptor(config);
instanceUnderTest.intercept(request);
// THEN
ArgumentCaptor<HttpContent> contentCaptor = ArgumentCaptor.forClass(HttpContent.class);
verify(request).setContent(contentCaptor.capture());
ByteArrayOutputStream encryptedPayloadStream = new ByteArrayOutputStream();
contentCaptor.getValue().writeTo(encryptedPayloadStream);
String encryptedPayload = encryptedPayloadStream.toString(StandardCharsets.UTF_8.name());
Assert.assertFalse(encryptedPayload.contains("foo"));
Assert.assertTrue(encryptedPayload.contains("encryptedFoo"));
assertEquals(encryptedPayload.length(), httpHeaders.getContentLength().intValue());
}
private String getEnvelope(SOAPMessage message) throws SOAPException, IOException {
ByteArrayOutputStream stream = new ByteArrayOutputStream();
String var3;
try {
message.writeTo(stream);
if (stream.size() >= 1232896) {
var3 = "message to large to log";
return var3;
}
var3 = stream.toString(Charset.UTF_8.getName());
} finally {
ConnectorIOUtils.closeQuietly((Object)stream);
}
return var3;
}
@Test
public void validationFailuresCausedByProjectionsAreDetected() throws Exception {
PrintStream out = System.out;
ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
PrintStream printStream = new PrintStream(outputStream);
System.setOut(printStream);
CliError e = Assertions.assertThrows(CliError.class, () -> {
String model = getClass().getResource("valid-model.smithy").getPath();
String config = getClass().getResource("projection-build-failure.json").getPath();
SmithyCli.create().run("build", "--debug", "--config", config, model);
});
System.setOut(out);
String output = outputStream.toString("UTF-8");
assertThat(output, containsString("ResourceLifecycle"));
assertThat(e.getMessage(),
containsString("The following 1 Smithy build projection(s) failed: [exampleProjection]"));
}
private String inputStream2String(InputStream is) throws IOException {
byte[] buf = new byte[1024];
ByteArrayOutputStream baos = new ByteArrayOutputStream();
for (int i; (i = is.read(buf)) != -1; ) {
baos.write(buf, 0, i);
}
String data = baos.toString("UTF-8");
baos.close();
return data;
}
@Override
public String convert(Properties source) {
try {
ByteArrayOutputStream os = new ByteArrayOutputStream(256);
source.store(os, null);
return os.toString("ISO-8859-1");
}
catch (IOException ex) {
// Should never happen.
throw new IllegalArgumentException("Failed to store [" + source + "] into String", ex);
}
}
void testRun() throws BadArgs, IOException {
System.err.println("test run(String[])");
DocLint dl = new DocLint();
String[] args = { "-help" };
ByteArrayOutputStream baos = new ByteArrayOutputStream();
PrintStream ps = new PrintStream(baos);
PrintStream prev = System.out;
try {
System.setOut(ps);
dl.run(args);
} finally {
System.setOut(prev);
}
ps.close();
String stdout = baos.toString();
StringWriter sw = new StringWriter();
PrintWriter pw = new PrintWriter(sw);
dl.run(pw, args);
pw.close();
String direct = sw.toString();
if (!stdout.equals(direct)) {
error("unexpected output");
System.err.println("EXPECT>>" + direct + "<<");
System.err.println("FOUND>>" + stdout + "<<");
}
}
String getDatasetXML() {
if (gridDataset == null)
return "";
try {
ByteArrayOutputStream bos = new ByteArrayOutputStream(10000);
GridDatasetInfo info = new GridDatasetInfo(gridDataset, "path");
info.writeXML(info.makeDatasetDescription(), bos);
return bos.toString(StandardCharsets.UTF_8.name());
} catch (IOException ioe) {
ioe.printStackTrace();
}
return "";
}
public static String readStringFromStream(InputStream inputStream) throws IOException {
ByteArrayOutputStream result = new ByteArrayOutputStream();
byte[] buffer = new byte[1024];
int length;
while ((length = inputStream.read(buffer)) != -1) {
result.write(buffer, 0, length);
}
return result.toString(StandardCharsets.UTF_8.name());
}
@Override
public String getClusterDescription() {
try {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
PrintStream ps = new PrintStream(baos);
YarnClusterMetrics metrics = yarnClient.getYarnClusterMetrics();
ps.append("NodeManagers in the ClusterClient " + metrics.getNumNodeManagers());
List<NodeReport> nodes = yarnClient.getNodeReports(NodeState.RUNNING);
final String format = "|%-16s |%-16s %n";
ps.printf("|Property |Value %n");
ps.println("+---------------------------------------+");
int totalMemory = 0;
int totalCores = 0;
for (NodeReport rep : nodes) {
final Resource res = rep.getCapability();
totalMemory += res.getMemory();
totalCores += res.getVirtualCores();
ps.format(format, "NodeID", rep.getNodeId());
ps.format(format, "Memory", res.getMemory() + " MB");
ps.format(format, "vCores", res.getVirtualCores());
ps.format(format, "HealthReport", rep.getHealthReport());
ps.format(format, "Containers", rep.getNumContainers());
ps.println("+---------------------------------------+");
}
ps.println("Summary: totalMemory " + totalMemory + " totalCores " + totalCores);
List<QueueInfo> qInfo = yarnClient.getAllQueues();
for (QueueInfo q : qInfo) {
ps.println("Queue: " + q.getQueueName() + ", Current Capacity: " + q.getCurrentCapacity() + " Max Capacity: " +
q.getMaximumCapacity() + " Applications: " + q.getApplications().size());
}
return baos.toString();
} catch (Exception e) {
throw new RuntimeException("Couldn't get cluster description", e);
}
}
public static String Decompress(byte[] bytes) throws Exception {
Inflater decompressor = new Inflater();
decompressor.setInput(bytes);
// Create an expandable byte array to hold the decompressed data
ByteArrayOutputStream bos = new ByteArrayOutputStream(bytes.length);
byte[] buffer = new byte[1024];
try {
while (true) {
int count = decompressor.inflate(buffer);
if (count > 0) {
bos.write(buffer, 0, count);
}
else if (count == 0 && decompressor.finished()) {
break;
}
else {
throw new RuntimeException("Bad zip data, size: " + bytes.length);
}
}
}
finally {
decompressor.end();
}
bos.close();
return bos.toString("UTF-16LE");
}
protected String getMessage(MimeMessage mimeMessage) throws MessagingException, IOException {
DataHandler dataHandler = mimeMessage.getDataHandler();
ByteArrayOutputStream baos = new ByteArrayOutputStream();
dataHandler.writeTo(baos);
baos.flush();
return baos.toString();
}
@GET
@Path("blocking")
@Produces(TEXT_PLAIN)
public String testBlockingS3() {
LOG.info("Testing S3 Blocking client with bucket: " + SYNC_BUCKET);
String keyValue = UUID.randomUUID().toString();
String result = null;
try {
if (S3Utils.createBucket(s3Client, SYNC_BUCKET)) {
if (s3Client.putObject(S3Utils.createPutRequest(SYNC_BUCKET, keyValue),
RequestBody.fromString(SAMPLE_S3_OBJECT)) != null) {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
GetObjectResponse object = s3Client.getObject(S3Utils.createGetRequest(SYNC_BUCKET, keyValue),
ResponseTransformer.toOutputStream(baos));
if (object != null) {
result = metadata(object) + "+" + baos.toString();
}
}
}
} catch (Exception ex) {
LOG.error("Error during S3 operations.", ex);
return "ERROR";
}
return result;
}
/**
*
* @param pkgDto pkg info to add to xml
*/
public void addPackage(PackageDto pkgDto) {
long pkgId = pkgDto.getId().longValue();
List<String> eulas = new EulaManager().getEulasForPackage(pkgId);
Collection<String> keywords = TaskManager
.getChannelPackageKeywords(channelId, pkgId);
if (keywords.isEmpty() && eulas.isEmpty()) {
// this package has no keywords and no EULA
return;
}
try {
ByteArrayOutputStream st = new ByteArrayOutputStream();
SimpleContentHandler tmpHandler = getTemporaryHandler(st);
tmpHandler.startDocument();
addPackageBoilerplate(tmpHandler, pkgDto);
addEulas(pkgId, eulas, tmpHandler);
addKeywords(pkgId, keywords, tmpHandler);
tmpHandler.endElement("package");
tmpHandler.endDocument();
String pkg = st.toString();
handler.addCharacters(pkg);
}
catch (SAXException e) {
throw new RepomdRuntimeException(e);
}
}
@Override
public String writeToXML(Properties p) throws IOException {
final ByteArrayOutputStream baos = new ByteArrayOutputStream();
p.storeToXML(baos, "Test 8016344");
return baos.toString();
}
private void runFunctionNoInliningNamespaceTest(String TEST_NAME, boolean IPA)
{
boolean origIPA = OptimizerUtils.ALLOW_INTER_PROCEDURAL_ANALYSIS;
getAndLoadTestConfiguration(TEST_NAME);
fullDMLScriptName = SCRIPT_DIR + TEST_DIR + TEST_NAME + ".dml";
programArgs = new String[]{"-args", String.valueOf(rows), String.valueOf(cols), String.valueOf(val), output("Rout")};
PrintStream originalStdErr = System.err;
try
{
ByteArrayOutputStream baos = new ByteArrayOutputStream();
PrintStream newStdErr = new PrintStream(baos);
System.setErr(newStdErr);
OptimizerUtils.ALLOW_INTER_PROCEDURAL_ANALYSIS = IPA;
runTest(true, false, null, -1);
//compare output
double ret = HDFSTool.readDoubleFromHDFSFile(output("Rout"));
Assert.assertEquals(Double.valueOf(rows*cols*val*6), Double.valueOf(ret));
//compiled MR jobs
int expectNumCompiled = IPA ? 0 : 4;
Assert.assertEquals("Unexpected number of compiled MR jobs.", expectNumCompiled, Statistics.getNoOfCompiledSPInst());
//check executed MR jobs (should always be 0 due to dynamic recompilation)
int expectNumExecuted = 0;
Assert.assertEquals("Unexpected number of executed MR jobs.", expectNumExecuted, Statistics.getNoOfExecutedSPInst());
String stdErrString = baos.toString();
if (stdErrString != null && stdErrString.length() > 0)
Assert.fail("Unexpected parse error or DML script error: " + stdErrString);
}
catch (Exception e) {
e.printStackTrace(originalStdErr);
Assert.fail("Unexpected exception: " + e);
}
finally {
System.setErr(originalStdErr);
OptimizerUtils.ALLOW_INTER_PROCEDURAL_ANALYSIS = origIPA;
}
}
/**
* Reads the next line. A line ends with {@code "\n"} or {@code "\r\n"},
* this end of line marker is not included in the result.
*
* @return the next line from the input.
* @throws IOException for underlying {@code InputStream} errors.
* @throws EOFException for the end of source stream.
*/
public String readLine() throws IOException {
synchronized (in) {
if (buf == null) {
throw new IOException("LineReader is closed");
}
// Read more data if we are at the end of the buffered data.
// Though it's an error to read after an exception, we will let {@code fillBuf()}
// throw again if that happens; thus we need to handle end == -1 as well as end == pos.
if (pos >= end) {
fillBuf();
}
// Try to find LF in the buffered data and return the line if successful.
for (int i = pos; i != end; ++i) {
if (buf[i] == LF) {
int lineEnd = (i != pos && buf[i - 1] == CR) ? i - 1 : i;
String res = new String(buf, pos, lineEnd - pos);
pos = i + 1;
return res;
}
}
// Let's anticipate up to 80 characters on top of those already read.
ByteArrayOutputStream out = new ByteArrayOutputStream(end - pos + 80) {
@Override
public String toString() {
int length = (count > 0 && buf[count - 1] == CR) ? count - 1 : count;
return new String(buf, 0, length);
}
};
while (true) {
out.write(buf, pos, end - pos);
// Mark unterminated line in case fillBuf throws EOFException or IOException.
end = -1;
fillBuf();
// Try to find LF in the buffered data and return the line if successful.
for (int i = pos; i != end; ++i) {
if (buf[i] == LF) {
if (i != pos) {
out.write(buf, pos, i - pos);
}
pos = i + 1;
return out.toString();
}
}
}
}
}
public String toString() {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
print(new PrintStream(bos));
return bos.toString();
}
public String toString() {
ByteArrayOutputStream byteOut = new ByteArrayOutputStream(1024);
PrintStream printOut = new PrintStream(byteOut, true);
printStream(printOut);
return super.toString() + " =\n" + byteOut.toString();
}
public static CodeWriter loadToCodeWriter(InputStream is) throws IOException {
ByteArrayOutputStream baos = new ByteArrayOutputStream(READ_BUFFER_SIZE);
copyStream(is, baos);
return new CodeWriter(baos.toString("UTF-8"));
}
/**
* Returns a <code>String</code> representation of the specified
* <code>NodeList</code>.
* <p/>
* This is a special case because the NodeList may represent a
* <code>DocumentFragment</code>. A document fragment may be a
* non-valid XML document (refer to appropriate description of
* W3C) because it my start with a non-element node, e.g. a text
* node.
* <p/>
* The methods first converts the node list into a document fragment.
* Special care is taken to not destroy the current document, thus
* the method clones the nodes (deep cloning) before it appends
* them to the document fragment.
* <p/>
* Refer also to comments about setup of format.
*
* @param content the <code>NodeList</code> to serialize.
* @return the <code>String</code> representation of the serialized
* <code>NodeList</code>.
* @throws Exception
*/
public String serialize(NodeList content) throws Exception {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
canon.setWriter(baos);
canon.notReset();
for (int i = 0; i < content.getLength(); i++) {
canon.canonicalizeSubtree(content.item(i));
}
String ret = baos.toString("UTF-8");
baos.reset();
return ret;
}