code stringlengths 73 34.1k | label stringclasses 1 value |
|---|---|
public final void notifyContentItemInserted(int position) {
int newHeaderItemCount = getHeaderItemCount();
int newContentItemCount = getContentItemCount();
if (position < 0 || position >= newContentItemCount) {
throw new IndexOutOfBoundsException("The given position " + position + " is not within the position bounds for content items [0 - " + (newContentItemCount - 1) + "].");
}
notifyItemInserted(position + newHeaderItemCount);
} | java |
public final void notifyContentItemRangeInserted(int positionStart, int itemCount) {
int newHeaderItemCount = getHeaderItemCount();
int newContentItemCount = getContentItemCount();
if (positionStart < 0 || itemCount < 0 || positionStart + itemCount > newContentItemCount) {
throw new IndexOutOfBoundsException("The given range [" + positionStart + " - "
+ (positionStart + itemCount - 1) + "] is not within the position bounds for content items [0 - "
+ (newContentItemCount - 1) + "].");
}
notifyItemRangeInserted(positionStart + newHeaderItemCount, itemCount);
} | java |
public final void notifyContentItemChanged(int position) {
if (position < 0 || position >= contentItemCount) {
throw new IndexOutOfBoundsException("The given position " + position
+ " is not within the position bounds for content items [0 - " + (contentItemCount - 1) + "].");
}
notifyItemChanged(position + headerItemCount);
} | java |
public final void notifyContentItemRangeChanged(int positionStart, int itemCount) {
if (positionStart < 0 || itemCount < 0 || positionStart + itemCount > contentItemCount) {
throw new IndexOutOfBoundsException("The given range [" + positionStart + " - "
+ (positionStart + itemCount - 1) + "] is not within the position bounds for content items [0 - "
+ (contentItemCount - 1) + "].");
}
notifyItemRangeChanged(positionStart + headerItemCount, itemCount);
} | java |
public final void notifyContentItemMoved(int fromPosition, int toPosition) {
if (fromPosition < 0 || toPosition < 0 || fromPosition >= contentItemCount || toPosition >= contentItemCount) {
throw new IndexOutOfBoundsException("The given fromPosition " + fromPosition + " or toPosition "
+ toPosition + " is not within the position bounds for content items [0 - " + (contentItemCount - 1) + "].");
}
notifyItemMoved(fromPosition + headerItemCount, toPosition + headerItemCount);
} | java |
public final void notifyContentItemRemoved(int position) {
if (position < 0 || position >= contentItemCount) {
throw new IndexOutOfBoundsException("The given position " + position
+ " is not within the position bounds for content items [0 - "
+ (contentItemCount - 1) + "].");
}
notifyItemRemoved(position + headerItemCount);
} | java |
public final void notifyContentItemRangeRemoved(int positionStart, int itemCount) {
if (positionStart < 0 || itemCount < 0 || positionStart + itemCount > contentItemCount) {
throw new IndexOutOfBoundsException("The given range [" + positionStart + " - "
+ (positionStart + itemCount - 1) + "] is not within the position bounds for content items [0 - "
+ (contentItemCount - 1) + "].");
}
notifyItemRangeRemoved(positionStart + headerItemCount, itemCount);
} | java |
public final void notifyFooterItemInserted(int position) {
int newHeaderItemCount = getHeaderItemCount();
int newContentItemCount = getContentItemCount();
int newFooterItemCount = getFooterItemCount();
// if (position < 0 || position >= newFooterItemCount) {
// throw new IndexOutOfBoundsException("The given position " + position
// + " is not within the position bounds for footer items [0 - "
// + (newFooterItemCount - 1) + "].");
// }
notifyItemInserted(position + newHeaderItemCount + newContentItemCount);
} | java |
public final void notifyFooterItemRangeInserted(int positionStart, int itemCount) {
int newHeaderItemCount = getHeaderItemCount();
int newContentItemCount = getContentItemCount();
int newFooterItemCount = getFooterItemCount();
if (positionStart < 0 || itemCount < 0 || positionStart + itemCount > newFooterItemCount) {
throw new IndexOutOfBoundsException("The given range [" + positionStart + " - "
+ (positionStart + itemCount - 1) + "] is not within the position bounds for footer items [0 - "
+ (newFooterItemCount - 1) + "].");
}
notifyItemRangeInserted(positionStart + newHeaderItemCount + newContentItemCount, itemCount);
} | java |
public final void notifyFooterItemChanged(int position) {
if (position < 0 || position >= footerItemCount) {
throw new IndexOutOfBoundsException("The given position " + position
+ " is not within the position bounds for footer items [0 - "
+ (footerItemCount - 1) + "].");
}
notifyItemChanged(position + headerItemCount + contentItemCount);
} | java |
public final void notifyFooterItemRangeChanged(int positionStart, int itemCount) {
if (positionStart < 0 || itemCount < 0 || positionStart + itemCount > footerItemCount) {
throw new IndexOutOfBoundsException("The given range [" + positionStart + " - "
+ (positionStart + itemCount - 1) + "] is not within the position bounds for footer items [0 - "
+ (footerItemCount - 1) + "].");
}
notifyItemRangeChanged(positionStart + headerItemCount + contentItemCount, itemCount);
} | java |
public final void notifyFooterItemMoved(int fromPosition, int toPosition) {
if (fromPosition < 0 || toPosition < 0 || fromPosition >= footerItemCount || toPosition >= footerItemCount) {
throw new IndexOutOfBoundsException("The given fromPosition " + fromPosition
+ " or toPosition " + toPosition + " is not within the position bounds for footer items [0 - "
+ (footerItemCount - 1) + "].");
}
notifyItemMoved(fromPosition + headerItemCount + contentItemCount, toPosition + headerItemCount + contentItemCount);
} | java |
public final void notifyFooterItemRangeRemoved(int positionStart, int itemCount) {
if (positionStart < 0 || itemCount < 0 || positionStart + itemCount > footerItemCount) {
throw new IndexOutOfBoundsException("The given range [" + positionStart + " - "
+ (positionStart + itemCount - 1) + "] is not within the position bounds for footer items [0 - "
+ (footerItemCount - 1) + "].");
}
notifyItemRangeRemoved(positionStart + headerItemCount + contentItemCount, itemCount);
} | java |
@Override
public View getView(int position, View convertView, ViewGroup parent) {
if (position == super.getCount() && isEnableRefreshing()) {
return (mFooter);
}
return (super.getView(position, convertView, parent));
} | java |
public static String[] addStringToArray(String[] array, String str) {
if (isEmpty(array)) {
return new String[]{str};
}
String[] newArr = new String[array.length + 1];
System.arraycopy(array, 0, newArr, 0, array.length);
newArr[array.length] = str;
return newArr;
} | java |
public static String[] sortStringArray(String[] array) {
if (isEmpty(array)) {
return new String[0];
}
Arrays.sort(array);
return array;
} | java |
public static String[] removeDuplicateStrings(String[] array) {
if (isEmpty(array)) {
return array;
}
Set<String> set = new TreeSet<String>();
Collections.addAll(set, array);
return toStringArray(set);
} | java |
public static Set<String> commaDelimitedListToSet(String str) {
Set<String> set = new TreeSet<String>();
String[] tokens = commaDelimitedListToStringArray(str);
Collections.addAll(set, tokens);
return set;
} | java |
public static String toSafeFileName(String name) {
int size = name.length();
StringBuilder builder = new StringBuilder(size * 2);
for (int i = 0; i < size; i++) {
char c = name.charAt(i);
boolean valid = c >= 'a' && c <= 'z';
valid = valid || (c >= 'A' && c <= 'Z');
valid = valid || (c >= '0' && c <= '9');
valid = valid || (c == '_') || (c == '-') || (c == '.');
if (valid) {
builder.append(c);
} else {
// Encode the character using hex notation
builder.append('x');
builder.append(Integer.toHexString(i));
}
}
return builder.toString();
} | java |
@Override
@Deprecated
public List<CardWithActions> getBoardMemberActivity(String boardId, String memberId,
String actionFilter, Argument... args) {
if (actionFilter == null)
actionFilter = "all";
Argument[] argsAndFilter = Arrays.copyOf(args, args.length + 1);
argsAndFilter[args.length] = new Argument("actions", actionFilter);
return asList(() -> get(createUrl(GET_BOARD_MEMBER_CARDS).params(argsAndFilter).asString(),
CardWithActions[].class, boardId, memberId));
} | java |
void sign(byte[] data, int offset, int length,
ServerMessageBlock request, ServerMessageBlock response) {
request.signSeq = signSequence;
if( response != null ) {
response.signSeq = signSequence + 1;
response.verifyFailed = false;
}
try {
update(macSigningKey, 0, macSigningKey.length);
int index = offset + ServerMessageBlock.SIGNATURE_OFFSET;
for (int i = 0; i < 8; i++) data[index + i] = 0;
ServerMessageBlock.writeInt4(signSequence, data, index);
update(data, offset, length);
System.arraycopy(digest(), 0, data, index, 8);
if (bypass) {
bypass = false;
System.arraycopy("BSRSPYL ".getBytes(), 0, data, index, 8);
}
} catch (Exception ex) {
if( log.level > 0 )
ex.printStackTrace( log );
} finally {
signSequence += 2;
}
} | java |
public static Object setProperty( String key, String value ) {
return prp.setProperty( key, value );
} | java |
public static NbtAddress[] getAllByAddress( NbtAddress addr )
throws UnknownHostException {
try {
NbtAddress[] addrs = CLIENT.getNodeStatus( addr );
cacheAddressArray( addrs );
return addrs;
} catch( UnknownHostException uhe ) {
throw new UnknownHostException( "no name with type 0x" +
Hexdump.toHexString( addr.hostName.hexCode, 2 ) +
((( addr.hostName.scope == null ) ||
( addr.hostName.scope.length() == 0 )) ?
" with no scope" : " with scope " + addr.hostName.scope ) +
" for host " + addr.getHostAddress() );
}
} | java |
public String getHostName() {
if( addr instanceof NbtAddress ) {
return ((NbtAddress)addr).getHostName();
}
return ((InetAddress)addr).getHostName();
} | java |
public String getHostAddress() {
if( addr instanceof NbtAddress ) {
return ((NbtAddress)addr).getHostAddress();
}
return ((InetAddress)addr).getHostAddress();
} | java |
public String getUncPath() {
getUncPath0();
if( share == null ) {
return "\\\\" + url.getHost();
}
return "\\\\" + url.getHost() + canon.replace( '/', '\\' );
} | java |
public void createNewFile() throws SmbException {
if( getUncPath0().length() == 1 ) {
throw new SmbException( "Invalid operation for workgroups, servers, or shares" );
}
close( open0( O_RDWR | O_CREAT | O_EXCL, 0, ATTR_NORMAL, 0 ), 0L );
} | java |
private String getProjectName() {
String pName = Strings.emptyToNull(projectName);
if (pName == null) {
pName = Strings.emptyToNull(junit4.getProject().getName());
}
if (pName == null) {
pName = "(unnamed project)";
}
return pName;
} | java |
@Subscribe
@SuppressForbidden("legitimate printStackTrace().")
public void onSuiteResult(AggregatedSuiteResultEvent e) {
try {
if (jsonWriter == null)
return;
slaves.put(e.getSlave().id, e.getSlave());
e.serialize(jsonWriter, outputStreams);
} catch (Exception ex) {
ex.printStackTrace();
junit4.log("Error serializing to JSON file: "
+ Throwables.getStackTraceAsString(ex), Project.MSG_WARN);
if (jsonWriter != null) {
try {
jsonWriter.close();
} catch (Throwable ignored) {
// Ignore.
} finally {
jsonWriter = null;
}
}
}
} | java |
@Subscribe
public void onQuit(AggregatedQuitEvent e) {
if (jsonWriter == null)
return;
try {
jsonWriter.endArray();
jsonWriter.name("slaves");
jsonWriter.beginObject();
for (Map.Entry<Integer, ForkedJvmInfo> entry : slaves.entrySet()) {
jsonWriter.name(Integer.toString(entry.getKey()));
entry.getValue().serialize(jsonWriter);
}
jsonWriter.endObject();
jsonWriter.endObject();
jsonWriter.flush();
if (!Strings.isNullOrEmpty(jsonpMethod)) {
writer.write(");");
}
jsonWriter.close();
jsonWriter = null;
writer = null;
if (method == OutputMethod.HTML) {
copyScaffolding(targetFile);
}
} catch (IOException x) {
junit4.log(x, Project.MSG_ERR);
}
} | java |
public void setSeed(String randomSeed) {
if (!Strings.isNullOrEmpty(getProject().getUserProperty(SYSPROP_RANDOM_SEED()))) {
String userProperty = getProject().getUserProperty(SYSPROP_RANDOM_SEED());
if (!userProperty.equals(randomSeed)) {
log("Ignoring seed attribute because it is overridden by user properties.", Project.MSG_WARN);
}
} else if (!Strings.isNullOrEmpty(randomSeed)) {
this.random = randomSeed;
}
} | java |
public void setPrefix(String prefix) {
if (!Strings.isNullOrEmpty(getProject().getUserProperty(SYSPROP_PREFIX()))) {
log("Ignoring prefix attribute because it is overridden by user properties.", Project.MSG_WARN);
} else {
SysGlobals.initializeWith(prefix);
}
} | java |
public void addFileSet(FileSet fs) {
add(fs);
if (fs.getProject() == null) {
fs.setProject(getProject());
}
} | java |
public void addAssertions(Assertions asserts) {
if (getCommandline().getAssertions() != null) {
throw new BuildException("Only one assertion declaration is allowed");
}
getCommandline().setAssertions(asserts);
} | java |
private void validateArguments() throws BuildException {
Path tempDir = getTempDir();
if (tempDir == null) {
throw new BuildException("Temporary directory cannot be null.");
}
if (Files.exists(tempDir)) {
if (!Files.isDirectory(tempDir)) {
throw new BuildException("Temporary directory is not a folder: " + tempDir.toAbsolutePath());
}
} else {
try {
Files.createDirectories(tempDir);
} catch (IOException e) {
throw new BuildException("Failed to create temporary folder: " + tempDir, e);
}
}
} | java |
private void validateJUnit4() throws BuildException {
try {
Class<?> clazz = Class.forName("org.junit.runner.Description");
if (!Serializable.class.isAssignableFrom(clazz)) {
throw new BuildException("At least JUnit version 4.10 is required on junit4's taskdef classpath.");
}
} catch (ClassNotFoundException e) {
throw new BuildException("JUnit JAR must be added to junit4 taskdef's classpath.");
}
} | java |
private org.apache.tools.ant.types.Path resolveFiles(org.apache.tools.ant.types.Path path) {
org.apache.tools.ant.types.Path cloned = new org.apache.tools.ant.types.Path(getProject());
for (String location : path.list()) {
cloned.createPathElement().setLocation(new File(location));
}
return cloned;
} | java |
private int determineForkedJvmCount(TestsCollection testCollection) {
int cores = Runtime.getRuntime().availableProcessors();
int jvmCount;
if (this.parallelism.equals(PARALLELISM_AUTO)) {
if (cores >= 8) {
// Maximum parallel jvms is 4, conserve some memory and memory bandwidth.
jvmCount = 4;
} else if (cores >= 4) {
// Make some space for the aggregator.
jvmCount = 3;
} else if (cores == 3) {
// Yes, three-core chips are a thing.
jvmCount = 2;
} else {
// even for dual cores it usually makes no sense to fork more than one
// JVM.
jvmCount = 1;
}
} else if (this.parallelism.equals(PARALLELISM_MAX)) {
jvmCount = Runtime.getRuntime().availableProcessors();
} else {
try {
jvmCount = Math.max(1, Integer.parseInt(parallelism));
} catch (NumberFormatException e) {
throw new BuildException("parallelism must be 'auto', 'max' or a valid integer: "
+ parallelism);
}
}
if (!testCollection.hasReplicatedSuites()) {
jvmCount = Math.min(testCollection.testClasses.size(), jvmCount);
}
return jvmCount;
} | java |
private String escapeAndJoin(String[] commandline) {
// TODO: we should try to escape special characters here, depending on the OS.
StringBuilder b = new StringBuilder();
Pattern specials = Pattern.compile("[\\ ]");
for (String arg : commandline) {
if (b.length() > 0) {
b.append(" ");
}
if (specials.matcher(arg).find()) {
b.append('"').append(arg).append('"');
} else {
b.append(arg);
}
}
return b.toString();
} | java |
@SuppressForbidden("legitimate sysstreams.")
private Execute forkProcess(ForkedJvmInfo slaveInfo, EventBus eventBus,
CommandlineJava commandline,
TailInputStream eventStream, OutputStream sysout, OutputStream syserr, RandomAccessFile streamsBuffer) {
try {
String tempDir = commandline.getSystemProperties().getVariablesVector().stream()
.filter(v -> v.getKey().equals("java.io.tmpdir"))
.map(v -> v.getValue())
.findAny()
.orElse(null);
final LocalSlaveStreamHandler streamHandler =
new LocalSlaveStreamHandler(
eventBus, testsClassLoader, System.err, eventStream,
sysout, syserr, heartbeat, streamsBuffer);
// Add certain properties to allow identification of the forked JVM from within
// the subprocess. This can be used for policy files etc.
final Path cwd = getWorkingDirectory(slaveInfo, tempDir);
Variable v = new Variable();
v.setKey(CHILDVM_SYSPROP_CWD);
v.setFile(cwd.toAbsolutePath().normalize().toFile());
commandline.addSysproperty(v);
v = new Variable();
v.setKey(SYSPROP_TEMPDIR);
v.setFile(getTempDir().toAbsolutePath().normalize().toFile());
commandline.addSysproperty(v);
v = new Variable();
v.setKey(SysGlobals.CHILDVM_SYSPROP_JVM_ID);
v.setValue(Integer.toString(slaveInfo.id));
commandline.addSysproperty(v);
v = new Variable();
v.setKey(SysGlobals.CHILDVM_SYSPROP_JVM_COUNT);
v.setValue(Integer.toString(slaveInfo.slaves));
commandline.addSysproperty(v);
// Emit command line before -stdin to avoid confusion.
slaveInfo.slaveCommandLine = escapeAndJoin(commandline.getCommandline());
log("Forked child JVM at '" + cwd.toAbsolutePath().normalize() +
"', command (may need escape sequences for your shell):\n" +
slaveInfo.slaveCommandLine, Project.MSG_VERBOSE);
final Execute execute = new Execute();
execute.setCommandline(commandline.getCommandline());
execute.setVMLauncher(true);
execute.setWorkingDirectory(cwd.toFile());
execute.setStreamHandler(streamHandler);
execute.setNewenvironment(newEnvironment);
if (env.getVariables() != null)
execute.setEnvironment(env.getVariables());
log("Starting JVM J" + slaveInfo.id, Project.MSG_DEBUG);
execute.execute();
return execute;
} catch (IOException e) {
throw new BuildException("Could not start the child process. Run ant with -verbose to get" +
" the execution details.", e);
}
} | java |
private Path getTempDir() {
if (this.tempDir == null) {
if (this.dir != null) {
this.tempDir = dir;
} else {
this.tempDir = getProject().getBaseDir().toPath();
}
}
return tempDir;
} | java |
private org.apache.tools.ant.types.Path addSlaveClasspath() {
org.apache.tools.ant.types.Path path = new org.apache.tools.ant.types.Path(getProject());
String [] REQUIRED_SLAVE_CLASSES = {
SlaveMain.class.getName(),
Strings.class.getName(),
MethodGlobFilter.class.getName(),
TeeOutputStream.class.getName()
};
for (String clazz : Arrays.asList(REQUIRED_SLAVE_CLASSES)) {
String resource = clazz.replace(".", "/") + ".class";
File f = LoaderUtils.getResourceSource(getClass().getClassLoader(), resource);
if (f != null) {
path.createPath().setLocation(f);
} else {
throw new BuildException("Could not locate classpath for resource: " + resource);
}
}
return path;
} | java |
private void validate() {
if (Strings.emptyToNull(random) == null) {
random = Strings.emptyToNull(getProject().getProperty(SYSPROP_RANDOM_SEED()));
}
if (random == null) {
throw new BuildException("Required attribute 'seed' must not be empty. Look at <junit4:pickseed>.");
}
long[] seeds = SeedUtils.parseSeedChain(random);
if (seeds.length < 1) {
throw new BuildException("Random seed is required.");
}
if (values.isEmpty() && !allowUndefined) {
throw new BuildException("No values to pick from and allowUndefined=false.");
}
} | java |
public void add(ResourceCollection rc) {
if (rc instanceof FileSet) {
FileSet fs = (FileSet) rc;
fs.setProject(getProject());
}
resources.add(rc);
} | java |
private static void verifyJUnit4Present() {
try {
Class<?> clazz = Class.forName("org.junit.runner.Description");
if (!Serializable.class.isAssignableFrom(clazz)) {
JvmExit.halt(SlaveMain.ERR_OLD_JUNIT);
}
} catch (ClassNotFoundException e) {
JvmExit.halt(SlaveMain.ERR_NO_JUNIT);
}
} | java |
public void setShowOutput(String mode) {
try {
this.outputMode = OutputMode.valueOf(mode.toUpperCase(Locale.ROOT));
} catch (IllegalArgumentException e) {
throw new IllegalArgumentException("showOutput accepts any of: "
+ Arrays.toString(OutputMode.values()) + ", value is not valid: " + mode);
}
} | java |
private void flushOutput() throws IOException {
outStream.flush();
outWriter.completeLine();
errStream.flush();
errWriter.completeLine();
} | java |
private void emitSuiteStart(Description description, long startTimestamp) throws IOException {
String suiteName = description.getDisplayName();
if (useSimpleNames) {
if (suiteName.lastIndexOf('.') >= 0) {
suiteName = suiteName.substring(suiteName.lastIndexOf('.') + 1);
}
}
logShort(shortTimestamp(startTimestamp) +
"Suite: " +
FormattingUtils.padTo(maxClassNameColumns, suiteName, "[...]"));
} | java |
private void emitSuiteEnd(AggregatedSuiteResultEvent e, int suitesCompleted) throws IOException {
assert showSuiteSummary;
final StringBuilder b = new StringBuilder();
final int totalErrors = this.totalErrors.addAndGet(e.isSuccessful() ? 0 : 1);
b.append(String.format(Locale.ROOT, "%sCompleted [%d/%d%s]%s in %.2fs, ",
shortTimestamp(e.getStartTimestamp() + e.getExecutionTime()),
suitesCompleted,
totalSuites,
totalErrors == 0 ? "" : " (" + totalErrors + "!)",
e.getSlave().slaves > 1 ? " on J" + e.getSlave().id : "",
e.getExecutionTime() / 1000.0d));
b.append(e.getTests().size()).append(Pluralize.pluralize(e.getTests().size(), " test"));
int failures = e.getFailureCount();
if (failures > 0) {
b.append(", ").append(failures).append(Pluralize.pluralize(failures, " failure"));
}
int errors = e.getErrorCount();
if (errors > 0) {
b.append(", ").append(errors).append(Pluralize.pluralize(errors, " error"));
}
int ignored = e.getIgnoredCount();
if (ignored > 0) {
b.append(", ").append(ignored).append(" skipped");
}
if (!e.isSuccessful()) {
b.append(FAILURE_STRING);
}
b.append("\n");
logShort(b, false);
} | java |
private void emitStatusLine(AggregatedResultEvent result, TestStatus status, long timeMillis) throws IOException {
final StringBuilder line = new StringBuilder();
line.append(shortTimestamp(result.getStartTimestamp()));
line.append(Strings.padEnd(statusNames.get(status), 8, ' '));
line.append(formatDurationInSeconds(timeMillis));
if (forkedJvmCount > 1) {
line.append(String.format(Locale.ROOT, jvmIdFormat, result.getSlave().id));
}
line.append(" | ");
line.append(formatDescription(result.getDescription()));
if (!result.isSuccessful()) {
line.append(FAILURE_MARKER);
}
line.append("\n");
if (showThrowable) {
// GH-82 (cause for ignored tests).
if (status == TestStatus.IGNORED && result instanceof AggregatedTestResultEvent) {
final StringWriter sw = new StringWriter();
PrefixedWriter pos = new PrefixedWriter(indent, sw, DEFAULT_MAX_LINE_WIDTH);
pos.write("Cause: ");
pos.write(((AggregatedTestResultEvent) result).getCauseForIgnored());
pos.completeLine();
line.append(sw.toString());
}
final List<FailureMirror> failures = result.getFailures();
if (!failures.isEmpty()) {
final StringWriter sw = new StringWriter();
PrefixedWriter pos = new PrefixedWriter(indent, sw, DEFAULT_MAX_LINE_WIDTH);
int count = 0;
for (FailureMirror fm : failures) {
count++;
if (fm.isAssumptionViolation()) {
pos.write(String.format(Locale.ROOT,
"Assumption #%d: %s",
count, MoreObjects.firstNonNull(fm.getMessage(), "(no message)")));
} else {
pos.write(String.format(Locale.ROOT,
"Throwable #%d: %s",
count,
showStackTraces ? filterStackTrace(fm.getTrace()) : fm.getThrowableString()));
}
}
pos.completeLine();
if (sw.getBuffer().length() > 0) {
line.append(sw.toString());
}
}
}
logShort(line);
} | java |
private void logShort(CharSequence message, boolean trim) throws IOException {
int length = message.length();
if (trim) {
while (length > 0 && Character.isWhitespace(message.charAt(length - 1))) {
length--;
}
}
char [] chars = new char [length + 1];
for (int i = 0; i < length; i++) {
chars[i] = message.charAt(i);
}
chars[length] = '\n';
output.write(chars);
} | java |
public int getIgnoredCount() {
int count = 0;
for (AggregatedTestResultEvent t : getTests()) {
if (t.getStatus() == TestStatus.IGNORED ||
t.getStatus() == TestStatus.IGNORED_ASSUMPTION) {
count++;
}
}
return count;
} | java |
@Subscribe
public void onQuit(AggregatedQuitEvent e) {
if (summaryFile != null) {
try {
Persister persister = new Persister();
persister.write(new MavenFailsafeSummaryModel(summaryListener.getResult()), summaryFile);
} catch (Exception x) {
junit4.log("Could not serialize summary report.", x, Project.MSG_WARN);
}
}
} | java |
@Subscribe
public void onSuiteResult(AggregatedSuiteResultEvent e) {
// Calculate summaries.
summaryListener.suiteSummary(e);
Description suiteDescription = e.getDescription();
String displayName = suiteDescription.getDisplayName();
if (displayName.trim().isEmpty()) {
junit4.log("Could not emit XML report for suite (null description).",
Project.MSG_WARN);
return;
}
if (!suiteCounts.containsKey(displayName)) {
suiteCounts.put(displayName, 1);
} else {
int newCount = suiteCounts.get(displayName) + 1;
suiteCounts.put(displayName, newCount);
if (!ignoreDuplicateSuites && newCount == 2) {
junit4.log("Duplicate suite name used with XML reports: "
+ displayName + ". This may confuse tools that process XML reports. "
+ "Set 'ignoreDuplicateSuites' to true to skip this message.", Project.MSG_WARN);
}
displayName = displayName + "-" + newCount;
}
try {
File reportFile = new File(dir, "TEST-" + displayName + ".xml");
RegistryMatcher rm = new RegistryMatcher();
rm.bind(String.class, new XmlStringTransformer());
Persister persister = new Persister(rm);
persister.write(buildModel(e), reportFile);
} catch (Exception x) {
junit4.log("Could not serialize report for suite "
+ displayName + ": " + x.toString(), x, Project.MSG_WARN);
}
} | java |
private TestSuiteModel buildModel(AggregatedSuiteResultEvent e) throws IOException {
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss", Locale.ROOT);
TestSuiteModel suite = new TestSuiteModel();
suite.hostname = "nohost.nodomain";
suite.name = e.getDescription().getDisplayName();
suite.properties = buildModel(e.getSlave().getSystemProperties());
suite.time = e.getExecutionTime() / 1000.0;
suite.timestamp = df.format(new Date(e.getStartTimestamp()));
suite.testcases = buildModel(e.getTests());
suite.tests = suite.testcases.size();
if (mavenExtensions) {
suite.skipped = 0;
}
// Suite-level failures and errors are simulated as test cases.
for (FailureMirror m : e.getFailures()) {
TestCaseModel model = new TestCaseModel();
model.classname = "junit.framework.TestSuite"; // empirical ANT output.
model.name = applyFilters(m.getDescription().getClassName());
model.time = 0;
if (m.isAssertionViolation()) {
model.failures.add(buildModel(m));
} else {
model.errors.add(buildModel(m));
}
suite.testcases.add(model);
}
// Calculate test numbers that match limited view (no ignored tests,
// faked suite-level errors).
for (TestCaseModel tc : suite.testcases) {
suite.errors += tc.errors.size();
suite.failures += tc.failures.size();
if (mavenExtensions && tc.skipped != null) {
suite.skipped += 1;
}
}
StringWriter sysout = new StringWriter();
StringWriter syserr = new StringWriter();
if (outputStreams) {
e.getSlave().decodeStreams(e.getEventStream(), sysout, syserr);
}
suite.sysout = sysout.toString();
suite.syserr = syserr.toString();
return suite;
} | java |
private String applyFilters(String methodName) {
if (filters.isEmpty()) {
return methodName;
}
Reader in = new StringReader(methodName);
for (TokenFilter tf : filters) {
in = tf.chain(in);
}
try {
return CharStreams.toString(in);
} catch (IOException e) {
junit4.log("Could not apply filters to " + methodName +
": " + Throwables.getStackTraceAsString(e), Project.MSG_WARN);
return methodName;
}
} | java |
void pumpEvents(InputStream eventStream) {
try {
Deserializer deserializer = new Deserializer(eventStream, refLoader);
IEvent event = null;
while ((event = deserializer.deserialize()) != null) {
switch (event.getType()) {
case APPEND_STDERR:
case APPEND_STDOUT:
// Ignore these two on activity heartbeats. GH-117
break;
default:
lastActivity = System.currentTimeMillis();
break;
}
try {
switch (event.getType()) {
case QUIT:
eventBus.post(event);
return;
case IDLE:
eventBus.post(new SlaveIdle(stdinWriter));
break;
case BOOTSTRAP:
clientCharset = Charset.forName(((BootstrapEvent) event).getDefaultCharsetName());
stdinWriter = new OutputStreamWriter(stdin, clientCharset);
eventBus.post(event);
break;
case APPEND_STDERR:
case APPEND_STDOUT:
assert streamsBuffer.getFilePointer() == streamsBuffer.length();
final long bufferStart = streamsBuffer.getFilePointer();
IStreamEvent streamEvent = (IStreamEvent) event;
streamEvent.copyTo(streamsBufferWrapper);
final long bufferEnd = streamsBuffer.getFilePointer();
event = new OnDiskStreamEvent(event.getType(), streamsBuffer, bufferStart, bufferEnd);
eventBus.post(event);
break;
default:
eventBus.post(event);
}
} catch (Throwable t) {
warnStream.println("Event bus dispatch error: " + t.toString());
t.printStackTrace(warnStream);
}
}
lastActivity = null;
} catch (Throwable e) {
if (!stopping) {
warnStream.println("Event stream error: " + e.toString());
e.printStackTrace(warnStream);
}
}
} | java |
@Subscribe
public void onSuiteResult(AggregatedSuiteResultEvent e) {
long millis = e.getExecutionTime();
String suiteName = e.getDescription().getDisplayName();
List<Long> values = hints.get(suiteName);
if (values == null) {
hints.put(suiteName, values = new ArrayList<>());
}
values.add(millis);
while (values.size() > historyLength)
values.remove(0);
} | java |
@Subscribe
public void onEnd(AggregatedQuitEvent e) {
try {
writeHints(hintsFile, hints);
} catch (IOException exception) {
outer.log("Could not write back the hints file.", exception, Project.MSG_ERR);
}
} | java |
public static Map<String,List<Long>> readHints(File hints) throws IOException {
Map<String,List<Long>> result = new HashMap<>();
InputStream is = new FileInputStream(hints);
mergeHints(is, result);
return result;
} | java |
public static void mergeHints(InputStream is, Map<String,List<Long>> hints) throws IOException {
final BufferedReader reader = new BufferedReader(
new InputStreamReader(is, Charsets.UTF_8));
String line;
while ((line = reader.readLine()) != null) {
line = line.trim();
if (line.isEmpty() || line.startsWith("#"))
continue;
final int equals = line.indexOf('=');
if (equals <= 0) {
throw new IOException("No '=' character on a non-comment line?: " + line);
} else {
String key = line.substring(0, equals);
List<Long> values = hints.get(key);
if (values == null) {
hints.put(key, values = new ArrayList<>());
}
for (String v : line.substring(equals + 1).split("[\\,]")) {
if (!v.isEmpty()) values.add(Long.parseLong(v));
}
}
}
} | java |
public static void writeHints(File file, Map<String,List<Long>> hints) throws IOException {
Closer closer = Closer.create();
try {
BufferedWriter w = closer.register(Files.newWriter(file, Charsets.UTF_8));
if (!(hints instanceof SortedMap)) {
hints = new TreeMap<String,List<Long>>(hints);
}
Joiner joiner = Joiner.on(',');
for (Map.Entry<String,List<Long>> e : hints.entrySet()) {
w.write(e.getKey());
w.write("=");
joiner.appendTo(w, e.getValue());
w.write("\n");
}
} catch (Throwable t) {
throw closer.rethrow(t);
} finally {
closer.close();
}
} | java |
private static String[] readArgsFile(String argsFile) throws IOException {
final ArrayList<String> lines = new ArrayList<String>();
final BufferedReader reader = new BufferedReader(
new InputStreamReader(
new FileInputStream(argsFile), "UTF-8"));
try {
String line;
while ((line = reader.readLine()) != null) {
line = line.trim();
if (!line.isEmpty() && !line.startsWith("#")) {
lines.add(line);
}
}
} finally {
reader.close();
}
return lines.toArray(new String [lines.size()]);
} | java |
@SuppressForbidden("legitimate sysstreams.")
private static void redirectStreams(final Serializer serializer, final boolean flushFrequently) {
final PrintStream origSysOut = System.out;
final PrintStream origSysErr = System.err;
// Set warnings stream to System.err.
warnings = System.err;
AccessController.doPrivileged(new PrivilegedAction<Void>() {
@SuppressForbidden("legitimate PrintStream with default charset.")
@Override
public Void run() {
System.setOut(new PrintStream(new BufferedOutputStream(new ChunkedStream() {
@Override
public void write(byte[] b, int off, int len) throws IOException {
if (multiplexStdStreams) {
origSysOut.write(b, off, len);
}
serializer.serialize(new AppendStdOutEvent(b, off, len));
if (flushFrequently) serializer.flush();
}
})));
System.setErr(new PrintStream(new BufferedOutputStream(new ChunkedStream() {
@Override
public void write(byte[] b, int off, int len) throws IOException {
if (multiplexStdStreams) {
origSysErr.write(b, off, len);
}
serializer.serialize(new AppendStdErrEvent(b, off, len));
if (flushFrequently) serializer.flush();
}
})));
return null;
}
});
} | java |
@SuppressForbidden("legitimate sysstreams.")
public static void warn(String message, Throwable t) {
PrintStream w = (warnings == null ? System.err : warnings);
try {
w.print("WARN: ");
w.print(message);
if (t != null) {
w.print(" -> ");
try {
t.printStackTrace(w);
} catch (OutOfMemoryError e) {
// Ignore, OOM.
w.print(t.getClass().getName());
w.print(": ");
w.print(t.getMessage());
w.println(" (stack unavailable; OOM)");
}
} else {
w.println();
}
w.flush();
} catch (OutOfMemoryError t2) {
w.println("ERROR: Couldn't even serialize a warning (out of memory).");
} catch (Throwable t2) {
// Can't do anything, really. Probably an OOM?
w.println("ERROR: Couldn't even serialize a warning.");
}
} | java |
private ArrayList<RunListener> instantiateRunListeners() throws Exception {
ArrayList<RunListener> instances = new ArrayList<>();
if (runListeners != null) {
for (String className : Arrays.asList(runListeners.split(","))) {
instances.add((RunListener) this.instantiate(className).newInstance());
}
}
return instances;
} | java |
@Override
public List<Assignment> assign(Collection<String> suiteNames, int slaves, long seed) {
// Read hints first.
final Map<String,List<Long>> hints = ExecutionTimesReport.mergeHints(resources, suiteNames);
// Preprocess and sort costs. Take the median for each suite's measurements as the
// weight to avoid extreme measurements from screwing up the average.
final List<SuiteHint> costs = new ArrayList<>();
for (String suiteName : suiteNames) {
final List<Long> suiteHint = hints.get(suiteName);
if (suiteHint != null) {
// Take the median for each suite's measurements as the weight
// to avoid extreme measurements from screwing up the average.
Collections.sort(suiteHint);
final Long median = suiteHint.get(suiteHint.size() / 2);
costs.add(new SuiteHint(suiteName, median));
}
}
Collections.sort(costs, SuiteHint.DESCENDING_BY_WEIGHT);
// Apply the assignment heuristic.
final PriorityQueue<SlaveLoad> pq = new PriorityQueue<SlaveLoad>(
slaves, SlaveLoad.ASCENDING_BY_ESTIMATED_FINISH);
for (int i = 0; i < slaves; i++) {
pq.add(new SlaveLoad(i));
}
final List<Assignment> assignments = new ArrayList<>();
for (SuiteHint hint : costs) {
SlaveLoad slave = pq.remove();
slave.estimatedFinish += hint.cost;
pq.add(slave);
owner.log("Expected execution time for " + hint.suiteName + ": " +
Duration.toHumanDuration(hint.cost),
Project.MSG_DEBUG);
assignments.add(new Assignment(hint.suiteName, slave.id, (int) hint.cost));
}
// Dump estimated execution times.
TreeMap<Integer, SlaveLoad> ordered = new TreeMap<Integer, SlaveLoad>();
while (!pq.isEmpty()) {
SlaveLoad slave = pq.remove();
ordered.put(slave.id, slave);
}
for (Integer id : ordered.keySet()) {
final SlaveLoad slave = ordered.get(id);
owner.log(String.format(Locale.ROOT,
"Expected execution time on JVM J%d: %8.2fs",
slave.id,
slave.estimatedFinish / 1000.0f),
verbose ? Project.MSG_INFO : Project.MSG_DEBUG);
}
return assignments;
} | java |
static <K, V> PageMetadata<K, V> mergeTokenAndQueryParameters(String paginationToken, final
ViewQueryParameters<K, V> initialParameters) {
// Decode the base64 token into JSON
String json = new String(Base64.decodeBase64(paginationToken), Charset.forName("UTF-8"));
// Get a suitable Gson, we need any adapter registered for the K key type
Gson paginationTokenGson = getGsonWithKeyAdapter(initialParameters);
// Deserialize the pagination token JSON, using the appropriate K, V types
PaginationToken token = paginationTokenGson.fromJson(json, PaginationToken.class);
// Create new query parameters using the initial ViewQueryParameters as a starting point.
ViewQueryParameters<K, V> tokenPageParameters = initialParameters.copy();
// Merge the values from the token into the new query parameters
tokenPageParameters.descending = token.descending;
tokenPageParameters.endkey = token.endkey;
tokenPageParameters.endkey_docid = token.endkey_docid;
tokenPageParameters.inclusive_end = token.inclusive_end;
tokenPageParameters.startkey = token.startkey;
tokenPageParameters.startkey_docid = token.startkey_docid;
return new PageMetadata<K, V>(token.direction, token
.pageNumber, tokenPageParameters);
} | java |
static String tokenize(PageMetadata<?, ?> pageMetadata) {
try {
Gson g = getGsonWithKeyAdapter(pageMetadata.pageRequestParameters);
return new String(Base64.encodeBase64URLSafe(g.toJson(new PaginationToken
(pageMetadata)).getBytes("UTF-8")),
Charset.forName("UTF-8"));
} catch (UnsupportedEncodingException e) {
//all JVMs should support UTF-8
throw new RuntimeException(e);
}
} | java |
public FindByIndexOptions useIndex(String designDocument, String indexName) {
assertNotNull(designDocument, "designDocument");
assertNotNull(indexName, "indexName");
JsonArray index = new JsonArray();
index.add(new JsonPrimitive(designDocument));
index.add(new JsonPrimitive(indexName));
this.useIndex = index;
return this;
} | java |
@Override
public String getPartialFilterSelector() {
return (def.selector != null) ? def.selector.toString() : null;
} | java |
public com.cloudant.client.api.model.ReplicationResult trigger() {
ReplicationResult couchDbReplicationResult = replication.trigger();
com.cloudant.client.api.model.ReplicationResult replicationResult = new com.cloudant
.client.api.model.ReplicationResult(couchDbReplicationResult);
return replicationResult;
} | java |
public Replication queryParams(Map<String, Object> queryParams) {
this.replication = replication.queryParams(queryParams);
return this;
} | java |
public Replication targetOauth(String consumerSecret,
String consumerKey, String tokenSecret, String token) {
this.replication = replication.targetOauth(consumerSecret, consumerKey,
tokenSecret, token);
return this;
} | java |
public List<Task> getActiveTasks() {
InputStream response = null;
URI uri = new URIBase(getBaseUri()).path("_active_tasks").build();
try {
response = couchDbClient.get(uri);
return getResponseList(response, couchDbClient.getGson(), DeserializationTypes.TASKS);
} finally {
close(response);
}
} | java |
public Membership getMembership() {
URI uri = new URIBase(getBaseUri()).path("_membership").build();
Membership membership = couchDbClient.get(uri,
Membership.class);
return membership;
} | java |
public ChangesResult getChanges() {
final URI uri = this.databaseHelper.changesUri("feed", "normal");
return client.get(uri, ChangesResult.class);
} | java |
public Changes parameter(String name, String value) {
this.databaseHelper.query(name, value);
return this;
} | java |
private boolean readNextRow() {
while (!stop) {
String row = getLineWrapped();
// end of stream - null indicates end of stream before we see last_seq which shouldn't
// be possible but we should handle it
if (row == null || row.startsWith("{\"last_seq\":")) {
terminate();
return false;
} else if (row.isEmpty()) {
// heartbeat
continue;
}
setNextRow(gson.fromJson(row, ChangesResult.Row.class));
return true;
}
// we were stopped, end of changes feed
terminate();
return false;
} | java |
public List<Shard> getShards() {
InputStream response = null;
try {
response = client.couchDbClient.get(new DatabaseURIHelper(db.getDBUri()).path("_shards")
.build());
return getResponseList(response, client.getGson(), DeserializationTypes.SHARDS);
} finally {
close(response);
}
} | java |
public Shard getShard(String docId) {
assertNotEmpty(docId, "docId");
return client.couchDbClient.get(new DatabaseURIHelper(db.getDBUri()).path("_shards")
.path(docId).build(),
Shard.class);
} | java |
@Deprecated
public <T> List<T> findByIndex(String selectorJson, Class<T> classOfT) {
return findByIndex(selectorJson, classOfT, new FindByIndexOptions());
} | java |
public <T> QueryResult<T> query(String partitionKey, String query, final Class<T> classOfT) {
URI uri = new DatabaseURIHelper(db.getDBUri()).partition(partitionKey).path("_find").build();
return this.query(uri, query, classOfT);
} | java |
public Indexes listIndexes() {
URI uri = new DatabaseURIHelper(db.getDBUri()).path("_index").build();
return client.couchDbClient.get(uri, Indexes.class);
} | java |
public void deleteIndex(String indexName, String designDocId, String type) {
assertNotEmpty(indexName, "indexName");
assertNotEmpty(designDocId, "designDocId");
assertNotNull(type, "type");
if (!designDocId.startsWith("_design")) {
designDocId = "_design/" + designDocId;
}
URI uri = new DatabaseURIHelper(db.getDBUri()).path("_index").path(designDocId)
.path(type).path(indexName).build();
InputStream response = null;
try {
HttpConnection connection = Http.DELETE(uri);
response = client.couchDbClient.executeToInputStream(connection);
getResponse(response, Response.class, client.getGson());
} finally {
close(response);
}
} | java |
public <T> T find(Class<T> classType, String id) {
return db.find(classType, id);
} | java |
public DbInfo info() {
return client.couchDbClient.get(new DatabaseURIHelper(db.getDBUri()).getDatabaseUri(),
DbInfo.class);
} | java |
public PartitionInfo partitionInfo(String partitionKey) {
if (partitionKey == null) {
throw new UnsupportedOperationException("Cannot get partition information for null partition key.");
}
URI uri = new DatabaseURIHelper(db.getDBUri()).partition(partitionKey).build();
return client.couchDbClient.get(uri, PartitionInfo.class);
} | java |
public static Expression type(String lhs, Type rhs) {
return new Expression(lhs, "$type", rhs.toString());
} | java |
public static PredicateExpression nin(Object... rhs) {
PredicateExpression ex = new PredicateExpression("$nin", rhs);
if (rhs.length == 1) {
ex.single = true;
}
return ex;
} | java |
public static PredicateExpression all(Object... rhs) {
PredicateExpression ex = new PredicateExpression( "$all", rhs);
if (rhs.length == 1) {
ex.single = true;
}
return ex;
} | java |
public ReplicationResult trigger() {
assertNotEmpty(source, "Source");
assertNotEmpty(target, "Target");
InputStream response = null;
try {
JsonObject json = createJson();
if (log.isLoggable(Level.FINE)) {
log.fine(json.toString());
}
final URI uri = new DatabaseURIHelper(client.getBaseUri()).path("_replicate").build();
response = client.post(uri, json.toString());
final InputStreamReader reader = new InputStreamReader(response, "UTF-8");
return client.getGson().fromJson(reader, ReplicationResult.class);
} catch (UnsupportedEncodingException e) {
// This should never happen as every implementation of the java platform is required
// to support UTF-8.
throw new RuntimeException(e);
} finally {
close(response);
}
} | java |
public Replication targetOauth(String consumerSecret, String consumerKey, String tokenSecret,
String token) {
targetOauth = new JsonObject();
this.consumerSecret = consumerSecret;
this.consumerKey = consumerKey;
this.tokenSecret = tokenSecret;
this.token = token;
return this;
} | java |
public static HttpConnection createPost(URI uri, String body, String contentType) {
HttpConnection connection = Http.POST(uri, "application/json");
if(body != null) {
setEntity(connection, body, contentType);
}
return connection;
} | java |
public static void setEntity(HttpConnection connnection, String body, String contentType) {
connnection.requestProperties.put("Content-type", contentType);
connnection.setRequestBody(body);
} | java |
public <T> void setState(HttpConnectionInterceptor interceptor, String stateName, T
stateObjectToStore) {
Map<String, Object> state = interceptorStates.get(interceptor);
if (state == null) {
interceptorStates.put(interceptor, (state = new ConcurrentHashMap<String, Object>()));
}
state.put(stateName, stateObjectToStore);
} | java |
public <T> T getState(HttpConnectionInterceptor interceptor, String stateName, Class<T>
stateType) {
Map<String, Object> state = interceptorStates.get(interceptor);
if (state != null) {
return stateType.cast(state.get(stateName));
} else {
return null;
}
} | java |
public DesignDocument get(String id) {
assertNotEmpty(id, "id");
return db.find(DesignDocument.class, ensureDesignPrefix(id));
} | java |
public DesignDocument get(String id, String rev) {
assertNotEmpty(id, "id");
assertNotEmpty(id, "rev");
return db.find(DesignDocument.class, ensureDesignPrefix(id), rev);
} | java |
public Response remove(String id) {
assertNotEmpty(id, "id");
id = ensureDesignPrefix(id);
String revision = null;
// Get the revision ID from ETag, removing leading and trailing "
revision = client.executeRequest(Http.HEAD(new DatabaseURIHelper(db.getDBUri()
).documentUri(id))).getConnection().getHeaderField("ETag");
if (revision != null) {
revision = revision.substring(1, revision.length() - 1);
return db.remove(id, revision);
} else {
throw new CouchDbException("No ETag header found for design document with id " + id);
}
} | java |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.