下面列出了java.security.spec.ECGenParameterSpec#java.io.PrintStream 实例代码,或者点击链接到github查看源代码,也可以在右侧发表评论。
/**
* Creates a new YAIL compiler.
*
* @param project project to build
* @param compTypes component types used in the project
* @param compBlocks component types mapped to blocks used in project
* @param out stdout stream for compiler messages
* @param err stderr stream for compiler messages
* @param userErrors stream to write user-visible error messages
* @param childProcessMaxRam maximum RAM for child processes, in MBs.
*/
@VisibleForTesting
Compiler(Project project, Set<String> compTypes, Map<String, Set<String>> compBlocks, PrintStream out, PrintStream err,
PrintStream userErrors, boolean isForCompanion, boolean isForEmulator, boolean includeDangerousPermissions,
int childProcessMaxRam, String dexCacheDir, BuildServer.ProgressReporter reporter) {
this.project = project;
this.compBlocks = compBlocks;
prepareCompTypes(compTypes);
readBuildInfo();
this.out = out;
this.err = err;
this.userErrors = userErrors;
this.isForCompanion = isForCompanion;
this.isForEmulator = isForEmulator;
this.includeDangerousPermissions = includeDangerousPermissions;
this.childProcessRamMb = childProcessMaxRam;
this.dexCacheDir = dexCacheDir;
this.reporter = reporter;
}
public void dumpReplayData(PrintStream out) {
NMethod nm = getNativeMethod();
int code_size = 0;
if (nm != null) {
code_size = (int)nm.codeEnd().minus(nm.getVerifiedEntryPoint());
}
Klass holder = getMethodHolder();
out.println("ciMethod " +
holder.getName().asString() + " " +
OopUtilities.escapeString(getName().asString()) + " " +
getSignature().asString() + " " +
getInvocationCount() + " " +
getBackedgeCount() + " " +
interpreterInvocationCount() + " " +
interpreterThrowoutCount() + " " +
code_size);
}
@Test
public void requireThatLogEntryWithLevelAboveThresholdIsNotOutput() {
ByteArrayOutputStream out = new ByteArrayOutputStream();
LogListener listener = new ConsoleLogListener(new PrintStream(out), null, "5");
for (int i = 0; i < 10; ++i) {
listener.logged(new MyEntry(0, i, "message"));
}
// TODO: Should use ConsoleLogFormatter.ABSENCE_REPLACEMENT instead of literal '-'. See ticket 7128315.
assertEquals("0.000000\t" + HOSTNAME + "\t" + PROCESS_ID + "\t-\t-\tunknown\tmessage\n" +
"0.000000\t" + HOSTNAME + "\t" + PROCESS_ID + "\t-\t-\terror\tmessage\n" +
"0.000000\t" + HOSTNAME + "\t" + PROCESS_ID + "\t-\t-\twarning\tmessage\n" +
"0.000000\t" + HOSTNAME + "\t" + PROCESS_ID + "\t-\t-\tinfo\tmessage\n" +
"0.000000\t" + HOSTNAME + "\t" + PROCESS_ID + "\t-\t-\tdebug\tmessage\n" +
"0.000000\t" + HOSTNAME + "\t" + PROCESS_ID + "\t-\t-\tunknown\tmessage\n",
out.toString());
}
/**
* Writes the merged properties to a single file while preserving any
* comments.
*
* @param fileContents list of file contents
* @throws Exception if the destination file can't be created
*/
private void writeFile(List fileContents) throws Exception {
Iterator iterate = fileContents.iterator();
try {
FileOutputStream out = new FileOutputStream(destFile);
PrintStream p = new PrintStream(out);
try {
// write original file with updated values
while (iterate.hasNext()) {
FileContents fc = (FileContents) iterate.next();
if (fc.comment != null && !fc.comment.equals("")) {
p.println();
p.print(fc.comment);
}
p.println(fc.value);
}
} catch (Exception e) {
throw new Exception("Could not write file: " + destFile, e);
} finally {
out.close();
}
} catch (IOException IOe) {
throw new Exception("Could not write file: " + destFile, IOe);
}
}
@Test
public void testReadBamList() throws IOException {
// Create a bam_list with one relative path and one absolute, and confirm that reader
// resolves them correctly.
final File bamList = TestUtils.getTempReportFile("testReadBamList.", ".bam_list");
final PrintStream out = new ErrorCheckingPrintStream(IOUtil.openFileForWriting(bamList));
final String relative = "foo.bam";
out.println(relative);
final String absolute = "/an/absolute/path.bam";
out.println(absolute);
out.close();
final List<File> expected = Arrays.asList(
new File(bamList.getCanonicalFile().getParent(), relative),
new File(absolute)
);
Assert.assertEquals(expected, FileListParsingUtils.readFileList(bamList));
// Confirm that when reading a symlink to a bam_list, relative paths are resolved relative to the directory
// of the actually bam_list file, not the directory containing the symlink.
final File otherDir = Files.createTempDirectory("testReadBamList").toFile();
otherDir.deleteOnExit();
final File symlink = new File(otherDir, "testReadBamList.bam_list");
symlink.deleteOnExit();
Files.createSymbolicLink(symlink.toPath(), bamList.toPath());
Assert.assertEquals(expected, FileListParsingUtils.readFileList(symlink));
}
@Test
public void processOptionsHeaderNoQuotas() {
LinkedList<String> options = new LinkedList<String>();
options.add("-v");
options.add("dummy");
PrintStream out = mock(PrintStream.class);
Count count = new Count();
count.out = out;
count.processOptions(options);
String noQuotasHeader =
// <----12----> <----12----> <-------18------->
" DIR_COUNT FILE_COUNT CONTENT_SIZE PATHNAME";
verify(out).println(noQuotasHeader);
verifyNoMoreInteractions(out);
}
@Override
public void backup(File f) throws IOException {
if (getString(URL_PGDUMP).length() <= 0) {
throw new NullPointerException("Please fill URL_PGDUMP var");
}
String dumpCommand = getString(URL_PGDUMP) + "/pg_dump" + " -d" + getString(DB_NAME)
+ " -h" + getString(SERVERNAME) + " -U" + getString(LOGIN) + " -p"
+ getString(SERVERPORT);
Runtime rt = Runtime.getRuntime();
logger.info("begin Backup :" + dumpCommand);
Process child = rt.exec(dumpCommand);
try (PrintStream ps = new PrintStream(f)) {
InputStream in = child.getInputStream();
int ch;
while ((ch = in.read()) != -1) {
ps.write(ch);
}
logger.info("Backup " + getString(DB_NAME) + " done");
}
}
@Override
protected int mainExec(OutputStream out, PrintStream err) throws IOException {
final CFlags flags = mFlags;
final PortableRandom random;
if (flags.isSet(SEED)) {
random = new PortableRandom((Integer) flags.getValue(SEED));
} else {
random = new PortableRandom();
}
final long seed = random.getSeed();
final int distance = (Integer) flags.getValue(DISTANCE);
final File input = (File) flags.getValue(REFERENCE_SDF);
final Mutator mutator = new Mutator((String) flags.getValue(SNP_SPECIFICATION));
final File outputVcf = VcfUtils.getZippedVcfFileName(true, (File) flags.getValue(OUTPUT_VCF));
final double af = (Double) flags.getValue(FREQUENCY);
try (SequencesReader dsr = SequencesReaderFactory.createMemorySequencesReader(input, true, LongRange.NONE)) {
final FixedStepPopulationVariantGenerator fs = new FixedStepPopulationVariantGenerator(dsr, distance, mutator, random, af);
PopulationVariantGenerator.writeAsVcf(outputVcf, fs.generatePopulation(), dsr, seed);
return 0;
}
}
/**
* Print the usage message for generic command-line options supported.
*
* @param out stream to print the usage message to.
*/
public static void printGenericCommandUsage(PrintStream out) {
out.println("Generic options supported are");
out.println("-conf <configuration file> specify an application configuration file");
out.println("-D <property=value> use value for given property");
out.println("-fs <local|namenode:port> specify a namenode");
out.println("-jt <local|jobtracker:port> specify a job tracker");
out.println("-files <comma separated list of files> " +
"specify comma separated files to be copied to the map reduce cluster");
out.println("-libjars <comma separated list of jars> " +
"specify comma separated jar files to include in the classpath.");
out.println("-archives <comma separated list of archives> " +
"specify comma separated archives to be unarchived" +
" on the compute machines.\n");
out.println("The general command line syntax is");
out.println("bin/hadoop command [genericOptions] [commandOptions]\n");
}
/**
* hasValidatingMcfInterface
*
* @param out output stream
* @param classname classname
* @param cl classloader
*/
private static void hasValidatingMcfInterface(PrintStream out, PrintStream error, String classname,
URLClassLoader cl)
{
try
{
out.print(" Validating: ");
Class<?> clazz = Class.forName(classname, true, cl);
if (hasInterface(clazz, "javax.resource.spi.ValidatingManagedConnectionFactory"))
{
out.println("Yes");
}
else
{
out.println("No");
}
}
catch (Throwable t)
{
// Nothing we can do
t.printStackTrace(error);
out.println("Unknown");
}
}
public void saveToChangeLog(File changeLogFile, ExtractChangeLogParser.ExtractChangeLogEntry changeLog) throws IOException {
FileOutputStream outputStream = new FileOutputStream(changeLogFile);
PrintStream stream = new PrintStream(outputStream, false, "UTF-8");
stream.println("<?xml version='1.0' encoding='UTF-8'?>");
stream.println("<extractChanges>");
stream.println("<entry>");
stream.println("<zipFile>" + escapeForXml(changeLog.getZipFile()) + "</zipFile>");
for (String fileName : changeLog.getAffectedPaths()) {
stream.println("<file>");
stream.println("<fileName>" + escapeForXml(fileName) + "</fileName>");
stream.println("</file>");
}
stream.println("</entry>");
stream.println("</extractChanges>");
stream.close();
}
public void printShort(PrintStream stream) {
if (getMethod() == null) {
stream.println(getSpecial());
} else {
int bc = isOsr() ? getOsr_bci() : -1;
stream.print(getId() + getMethod().decodeFlags(bc) + getMethod().format(bc));
}
}
/**
* Print
*/
public void print(PrintStream out) {
out.print("(" + opNames[op] + " ");
right.print(out);
out.print(" ");
if (index != null) {
index.print(out);
} else {
out.print("<empty>");
}
out.print(")");
}
@Override
public synchronized PrintStream append(
CharSequence csq, int start, int end) {
builder.append(csq, start, end);
flush(false);
return this;
}
private void buildAndCreateZip(String userName, File inputZipFile, ProgressReporter reporter)
throws IOException, JSONException {
Result buildResult = build(userName, inputZipFile, reporter);
boolean buildSucceeded = buildResult.succeeded();
outputZip = File.createTempFile(inputZipFile.getName(), ".zip");
outputZip.deleteOnExit(); // In case build server is killed before cleanUp executes.
ZipOutputStream zipOutputStream =
new ZipOutputStream(new BufferedOutputStream(new FileOutputStream(outputZip)));
if (buildSucceeded) {
if (outputKeystore != null) {
zipOutputStream.putNextEntry(new ZipEntry(outputKeystore.getName()));
Files.copy(outputKeystore, zipOutputStream);
}
zipOutputStream.putNextEntry(new ZipEntry(outputApk.getName()));
Files.copy(outputApk, zipOutputStream);
successfulBuildRequests.getAndIncrement();
} else {
LOG.severe("Build " + buildCount.get() + " Failed: " + buildResult.getResult() + " " + buildResult.getError());
failedBuildRequests.getAndIncrement();
}
zipOutputStream.putNextEntry(new ZipEntry("build.out"));
String buildOutputJson = genBuildOutput(buildResult);
PrintStream zipPrintStream = new PrintStream(zipOutputStream);
zipPrintStream.print(buildOutputJson);
zipPrintStream.flush();
zipOutputStream.flush();
zipOutputStream.close();
}
@Test
public void testStreamWritingOnDiscovery() throws Exception {
PrintStream printStream = mock(PrintStream.class);
AgentBuilder.Listener listener = new AgentBuilder.Listener.StreamWriting(printStream);
listener.onDiscovery(FOO, classLoader, module, LOADED);
verify(printStream).printf("[Byte Buddy] DISCOVERY %s [%s, %s, loaded=%b]%n", FOO, classLoader, module, LOADED);
verifyNoMoreInteractions(printStream);
}
@Before
public void captureInputOutput() throws Exception {
System.setProperty(WindowsTerminal.DIRECT_CONSOLE, "false"); // to be able to type input on Windows
inputLines = "";
capturedOutput = new ByteArrayOutputStream();
PrintStream captureOutput = new PrintStream(capturedOutput);
System.setOut(captureOutput);
}
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 + "<<");
}
}
public void test1() throws IOException {
final ByteArrayOutputStream baos = new ByteArrayOutputStream();
try (PrintStream ps = new PrintStream(baos)) {
RocSlope.writeSlope(new ByteArrayInputStream(ROC1.getBytes()), ps);
}
mNano.check("roc-slope-1.txt", TestUtils.sanitizeTsvHeader(baos.toString()));
}
/**
* Print
*/
public void print(PrintStream out, int indent) {
super.print(out, indent);
out.print("throw ");
expr.print(out);
out.print(":");
}
public Double genericV8Test(final String benchmark, final String testPath) throws Throwable {
System.out.println("genericV8Test");
if (!checkV8Presence()) {
return null;
}
final String v8shell = System.getProperty("v8.shell.full.path");
final PrintStream systemOut = System.out;
try {
final Process process = Runtime.getRuntime().exec(v8shell + " " + testPath);
process.waitFor();
final InputStream processOut = process.getInputStream();
final BufferedInputStream bis = new BufferedInputStream(processOut);
final byte[] output = new byte[bis.available()];
bis.read(output, 0, bis.available());
final List<String> result = outputToStrings(output);
return filterBenchmark(result, benchmark);
} catch (final Throwable e) {
System.setOut(systemOut);
e.printStackTrace();
throw e;
}
}
@Override public void writeBeginning(final PrintStream out) {
String targetCls = category.category.superClass.getFullPath();
out.format("\tpublic %1$s(final %2$s obj, final %3$s runtime) {\n" +
"\t\tsuper(obj, runtime);\n" +
"\t}\n",
className, targetCls, JObjCRuntime.class.getCanonicalName());
super.writeBeginning(out);
}
@Override public void writeBeginning(final PrintStream out) {
String targetCls = category.category.superClass.getFullPath();
out.format("\tpublic %1$s(final %2$s obj, final %3$s runtime) {\n" +
"\t\tsuper(obj, runtime);\n" +
"\t}\n",
className, targetCls, JObjCRuntime.class.getCanonicalName());
super.writeBeginning(out);
}
private void printInteger(PrintStream ps, TaggedValuePointable tvp) {
LongPointable lp = pp.takeOne(LongPointable.class);
try {
tvp.getValue(lp);
ps.print(lp.longValue());
} finally {
pp.giveBack(lp);
}
}
@Override
protected PrintStream initialValue() {
return AccessController.doPrivileged(new PrivilegedAction<PrintStream>() {
public PrintStream run() {
return new PrintStream(new LineBufferingOutputStream(handler));
}
});
}
public void printCommandHelp(PrintStream out, boolean helpType)
{
if (helpType == longHelp) {
out.println(CorbaResourceUtil.getText("servertool.listappnames"));
} else {
out.println(CorbaResourceUtil.getText("servertool.listappnames1"));
}
}
private boolean verifyRuleKeyCache(
CellProvider cellProvider,
PrintStream stdOut,
RuleKeyConfiguration ruleKeyConfiguration,
FileHashLoader fileHashLoader,
RuleKeyCacheRecycler<RuleKey> recycler) {
ImmutableList<Map.Entry<BuildRule, RuleKey>> contents = recycler.getCachedBuildRules();
RuleKeyFieldLoader fieldLoader = new RuleKeyFieldLoader(ruleKeyConfiguration);
ActionGraphBuilder graphBuilder =
new MultiThreadedActionGraphBuilder(
MoreExecutors.listeningDecorator(Executors.newSingleThreadExecutor()),
TargetGraph.EMPTY,
ConfigurationRuleRegistryFactory.createRegistry(TargetGraph.EMPTY),
new DefaultTargetNodeToBuildRuleTransformer(),
cellProvider);
contents.forEach(e -> graphBuilder.addToIndex(e.getKey()));
DefaultRuleKeyFactory defaultRuleKeyFactory =
new DefaultRuleKeyFactory(fieldLoader, fileHashLoader, graphBuilder);
stdOut.println(String.format("Examining %d build rule keys.", contents.size()));
ImmutableList<BuildRule> mismatches =
RichStream.from(contents)
.filter(entry -> !defaultRuleKeyFactory.build(entry.getKey()).equals(entry.getValue()))
.map(Map.Entry::getKey)
.toImmutableList();
if (mismatches.isEmpty()) {
stdOut.println("No rule key cache errors found.");
} else {
stdOut.println("Found rule key cache errors:");
for (BuildRule rule : mismatches) {
stdOut.println(String.format(" %s", rule));
}
}
return true;
}
@Override
protected void handleLabels(PrintStream out, List<String> labels) {
out.println("\t\t<tr>");
for (String label : labels) {
out.printf("\t\t\t<td>%s</td>%n", label);
}
out.println("\t\t</tr>");
}
static public void ShowException(PrintStream out, Throwable e) {
if (e == null) return;
if (e instanceof SQLException)
ShowSQLException(out, (SQLException)e);
else
e.printStackTrace(out);
}
@Test
public void testQualifiedFunctionsWithNulls() throws Throwable {
//create file
File tmpFile = File.createTempFile("test", ".txt");
PrintStream ps = new PrintStream(new FileOutputStream(tmpFile));
for(int i = 0; i < 1; i++) {
if ( i % 10 == 0 ){
ps.println("");
} else {
ps.println(i);
}
}
ps.close();
// execute query
String query = "foreach (group (load '"
+ Util.generateURI(tmpFile.toString(), pig.getPigContext())
+ "' using " + MyStorage.class.getName() + "()) by "
+ MyGroup.class.getName() + "('all')) generate flatten("
+ MyApply.class.getName() + "($1)) ;";
System.out.println(query);
pig.registerQuery("asdf_id = " + query);
//Verfiy query
Iterator<Tuple> it = pig.openIterator("asdf_id");
Tuple t;
int count = 0;
while(it.hasNext()) {
t = it.next();
assertEquals(t.get(0).toString(), "Got");
Integer.parseInt(t.get(1).toString());
count++;
}
assertEquals( MyStorage.COUNT, count );
tmpFile.delete();
}