language stringclasses 1 value | repo stringclasses 60 values | path stringlengths 22 294 | class_span dict | source stringlengths 13 1.16M | target stringlengths 1 113 |
|---|---|---|---|---|---|
java | grpc__grpc-java | binder/src/test/java/io/grpc/binder/internal/FlowControllerTest.java | {
"start": 818,
"end": 3734
} | class ____ {
@Test
public void shouldReportTransmitWindowInitiallyNonFull() {
FlowController flowController = new FlowController(100);
assertThat(flowController.isTransmitWindowFull()).isFalse();
}
@Test
public void shouldReportTransmitWindowFull() {
FlowController flowController = new FlowController(100);
boolean transition = flowController.notifyBytesSent(99);
assertThat(transition).isFalse();
assertThat(flowController.isTransmitWindowFull()).isFalse();
transition = flowController.notifyBytesSent(1);
assertThat(transition).isTrue();
assertThat(flowController.isTransmitWindowFull()).isTrue();
}
@Test
public void shouldHandleAck() {
FlowController flowController = new FlowController(100);
assertThat(flowController.isTransmitWindowFull()).isFalse();
flowController.notifyBytesSent(1);
flowController.notifyBytesSent(100);
assertThat(flowController.isTransmitWindowFull()).isTrue();
boolean transition = flowController.handleAcknowledgedBytes(100);
assertThat(transition).isTrue();
assertThat(flowController.isTransmitWindowFull()).isFalse();
transition = flowController.handleAcknowledgedBytes(1);
assertThat(transition).isFalse();
}
@Test
public void shouldHandleAcksOutOfOrder() {
FlowController flowController = new FlowController(100);
flowController.notifyBytesSent(49);
flowController.notifyBytesSent(51);
assertThat(flowController.isTransmitWindowFull()).isTrue();
flowController.handleAcknowledgedBytes(100);
assertThat(flowController.isTransmitWindowFull()).isFalse();
flowController.handleAcknowledgedBytes(49);
assertThat(flowController.isTransmitWindowFull()).isFalse();
}
@Test
public void shouldHandleAckOverflow() {
FlowController flowController = new FlowController(2);
// Signed long overflow
flowController.notifyBytesSent(Long.MAX_VALUE); // totalBytesSent = 0b011..1
flowController.handleAcknowledgedBytes(Long.MAX_VALUE); // totalBytesAckedByPeer = 0b011..1
assertThat(flowController.isTransmitWindowFull()).isFalse();
flowController.notifyBytesSent(1); // totalBytesSent = 0b100..00
assertThat(flowController.isTransmitWindowFull()).isFalse();
flowController.notifyBytesSent(1); // totalBytesSent = 0b100..01
assertThat(flowController.isTransmitWindowFull()).isTrue();
// Unsigned long overflow.
flowController.notifyBytesSent(Long.MAX_VALUE - 1); // totalBytesSent = 0b111..11
flowController.handleAcknowledgedBytes(-1); // totalBytesAckedByPeer = 0b111..1
assertThat(flowController.isTransmitWindowFull()).isFalse();
flowController.notifyBytesSent(1); // totalBytesSent = 0
assertThat(flowController.isTransmitWindowFull()).isFalse();
flowController.notifyBytesSent(1); // totalBytesSent = 1
assertThat(flowController.isTransmitWindowFull()).isTrue();
}
}
| FlowControllerTest |
java | spring-projects__spring-security | config/src/test/java/org/springframework/security/config/annotation/web/configurers/HttpSecuritySecurityMatchersTests.java | {
"start": 10493,
"end": 10929
} | class ____ {
@Bean
SecurityFilterChain appSecurity(HttpSecurity http) throws Exception {
// @formatter:off
http
.securityMatchers((matchers) -> matchers
.requestMatchers("/path")
)
.httpBasic(withDefaults())
.authorizeHttpRequests((authorize) -> authorize
.anyRequest().denyAll()
);
// @formatter:on
return http.build();
}
@RestController
static | SecurityMatchersMvcMatcherInLambdaConfig |
java | spring-projects__spring-framework | spring-webflux/src/test/java/org/springframework/web/reactive/result/method/annotation/MethodValidationTests.java | {
"start": 16970,
"end": 17848
} | class ____ {
void handle(@Valid @ModelAttribute("student") Person person) {
}
String handle(@Valid @ModelAttribute("student") Person person, Errors errors) {
return errors.toString();
}
void handle(@Valid @ModelAttribute("student") Person person, Errors errors,
@RequestHeader @Size(min = 5, max = 10) String myHeader) {
}
String handleValidated(@Validated Person person, Errors errors,
@RequestHeader @Size(min = 5, max = 10) String myHeader) {
return errors.toString();
}
void handle(@Valid @RequestBody List<Person> persons) {
}
Mono<String> handleAsync(@Valid @ModelAttribute("student") Mono<Person> person,
@RequestHeader @Size(min = 5, max = 10) String myHeader) {
return person.map(Person::toString);
}
}
@SuppressWarnings({"unused", "UnusedReturnValue", "SameParameterValue"})
@RestController
static | ValidController |
java | hibernate__hibernate-orm | hibernate-envers/src/test/java/org/hibernate/orm/test/envers/integration/ids/DateId.java | {
"start": 763,
"end": 1817
} | class ____ {
private Date id1;
@BeforeClassTemplate
public void initData(EntityManagerFactoryScope scope) {
// Revision 1
scope.inTransaction( em -> {
DateIdTestEntity dite = new DateIdTestEntity( new Date(), "x" );
em.persist( dite );
id1 = dite.getId();
} );
// Revision 2
scope.inTransaction( em -> {
DateIdTestEntity dite = em.find( DateIdTestEntity.class, id1 );
dite.setStr1( "y" );
} );
}
@Test
public void testRevisionsCounts(EntityManagerFactoryScope scope) {
scope.inEntityManager( em -> {
final var auditReader = AuditReaderFactory.get( em );
assertEquals( Arrays.asList( 1, 2 ), auditReader.getRevisions( DateIdTestEntity.class, id1 ) );
} );
}
@Test
public void testHistoryOfId1(EntityManagerFactoryScope scope) {
scope.inEntityManager( em -> {
final var auditReader = AuditReaderFactory.get( em );
assertEquals( "x", auditReader.find( DateIdTestEntity.class, id1, 1 ).getStr1() );
assertEquals( "y", auditReader.find( DateIdTestEntity.class, id1, 2 ).getStr1() );
} );
}
}
| DateId |
java | apache__flink | flink-runtime/src/main/java/org/apache/flink/runtime/state/restore/ThrowingIterator.java | {
"start": 1279,
"end": 1883
} | interface ____<E> extends Closeable {
/**
* Returns {@code true} if the iteration has more elements. (In other words, returns {@code
* true} if {@link #next} would return an element rather than throwing an exception.)
*
* @return {@code true} if the iteration has more elements
*/
boolean hasNext();
/**
* Returns the next element in the iteration.
*
* @return the next element in the iteration
* @throws NoSuchElementException if the iteration has no more elements
*/
E next() throws IOException, StateMigrationException;
}
| ThrowingIterator |
java | apache__maven | api/maven-api-di/src/main/java/org/apache/maven/api/di/Named.java | {
"start": 1566,
"end": 1966
} | interface ____ {
/**
* The name identifier for the annotated element.
* <p>
* If no value is specified, the default empty string will be used.
* When used as a qualifier, this value helps distinguish between different
* implementations or instances of the same type.
*
* @return the name that identifies this component
*/
String value() default "";
}
| Named |
java | quarkusio__quarkus | extensions/resteasy-classic/resteasy-jsonb/deployment/src/main/java/io/quarkus/resteasy/jsonb/deployment/ResteasyJsonbProcessor.java | {
"start": 467,
"end": 1409
} | class ____ {
private static final List<String> VERTX_SERIALIZERS = Arrays.asList(
VertxJson.JsonObjectSerializer.class.getName(),
VertxJson.JsonArraySerializer.class.getName());
private static final List<String> VERTX_DESERIALIZERS = Arrays.asList(
VertxJson.JsonObjectDeserializer.class.getName(),
VertxJson.JsonArrayDeserializer.class.getName());
@BuildStep
void feature(BuildProducer<FeatureBuildItem> feature) {
feature.produce(new FeatureBuildItem(Feature.RESTEASY_JSONB));
}
@BuildStep
public void registerVertxJsonSupport(
BuildProducer<JsonbSerializerBuildItem> serializers,
BuildProducer<JsonbDeserializerBuildItem> deserializers) {
serializers.produce(new JsonbSerializerBuildItem(VERTX_SERIALIZERS));
deserializers.produce(new JsonbDeserializerBuildItem(VERTX_DESERIALIZERS));
}
}
| ResteasyJsonbProcessor |
java | apache__spark | examples/src/main/java/org/apache/spark/examples/mllib/JavaBisectingKMeansExample.java | {
"start": 1364,
"end": 2411
} | class ____ {
public static void main(String[] args) {
SparkConf sparkConf = new SparkConf().setAppName("JavaBisectingKMeansExample");
JavaSparkContext sc = new JavaSparkContext(sparkConf);
// $example on$
List<Vector> localData = Arrays.asList(
Vectors.dense(0.1, 0.1), Vectors.dense(0.3, 0.3),
Vectors.dense(10.1, 10.1), Vectors.dense(10.3, 10.3),
Vectors.dense(20.1, 20.1), Vectors.dense(20.3, 20.3),
Vectors.dense(30.1, 30.1), Vectors.dense(30.3, 30.3)
);
JavaRDD<Vector> data = sc.parallelize(localData, 2);
BisectingKMeans bkm = new BisectingKMeans()
.setK(4);
BisectingKMeansModel model = bkm.run(data);
System.out.println("Compute Cost: " + model.computeCost(data));
Vector[] clusterCenters = model.clusterCenters();
for (int i = 0; i < clusterCenters.length; i++) {
Vector clusterCenter = clusterCenters[i];
System.out.println("Cluster Center " + i + ": " + clusterCenter);
}
// $example off$
sc.stop();
}
}
| JavaBisectingKMeansExample |
java | apache__flink | flink-datastream/src/test/java/org/apache/flink/datastream/impl/operators/MockSumAggregateProcessFunction.java | {
"start": 1553,
"end": 3609
} | class ____
implements OneInputStreamProcessFunction<Integer, Integer> {
private final AggregatingStateDeclaration<Integer, Integer, Integer>
aggregatingStateDeclaration =
StateDeclarations.aggregatingState(
"agg-state",
TypeDescriptors.INT,
new AggregateFunction<Integer, Integer, Integer>() {
@Override
public Integer createAccumulator() {
return 0;
}
@Override
public Integer add(Integer value, Integer accumulator) {
return value + accumulator;
}
@Override
public Integer getResult(Integer accumulator) {
return accumulator;
}
@Override
public Integer merge(Integer a, Integer b) {
return a + b;
}
});
@Override
public Set<StateDeclaration> usesStates() {
return new HashSet<>(Collections.singletonList(aggregatingStateDeclaration));
}
@Override
public void processRecord(
Integer record, Collector<Integer> output, PartitionedContext<Integer> ctx)
throws Exception {
Optional<AggregatingState<Integer, Integer>> stateOptional =
ctx.getStateManager().getStateOptional(aggregatingStateDeclaration);
if (!stateOptional.isPresent()) {
throw new RuntimeException("State is not available");
}
AggregatingState<Integer, Integer> state = stateOptional.get();
state.add(record);
output.collect(state.get());
}
}
| MockSumAggregateProcessFunction |
java | spring-projects__spring-security | config/src/test/java/org/springframework/security/config/annotation/web/configurers/HeadersConfigurerTests.java | {
"start": 42656,
"end": 43018
} | class ____ {
@Bean
SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
// @formatter:off
http
.headers((headers) -> headers
.defaultsDisabled()
.httpStrictTransportSecurity((hsts) -> hsts.preload(true)));
return http.build();
// @formatter:on
}
}
@Configuration
@EnableWebSecurity
static | HstsWithPreloadConfig |
java | elastic__elasticsearch | x-pack/plugin/esql/compute/src/main/generated-src/org/elasticsearch/compute/aggregation/TopFloatDoubleAggregator.java | {
"start": 4411,
"end": 5476
} | class ____ implements AggregatorState {
private final GroupingState internalState;
private SingleState(BigArrays bigArrays, int limit, boolean ascending) {
this.internalState = new GroupingState(bigArrays, limit, ascending);
}
public void add(float value, double outputValue) {
internalState.add(0, value, outputValue);
}
@Override
public void toIntermediate(Block[] blocks, int offset, DriverContext driverContext) {
try (var intValues = driverContext.blockFactory().newConstantIntVector(0, 1)) {
internalState.toIntermediate(blocks, offset, intValues, driverContext);
}
}
Block toBlock(BlockFactory blockFactory) {
try (var intValues = blockFactory.newConstantIntVector(0, 1)) {
return internalState.toBlock(blockFactory, intValues);
}
}
@Override
public void close() {
Releasables.closeExpectNoException(internalState);
}
}
}
| SingleState |
java | google__auto | value/src/it/functional/src/test/java/com/google/auto/value/AutoValueTest.java | {
"start": 62625,
"end": 63136
} | interface ____<T extends Comparable<T>> {
Builder<T> setList(List<T> list);
Builder<T> setT(T t);
BuilderWithSet<T> build();
}
}
@Test
public void testBuilderWithSet() {
List<Integer> integers = ImmutableList.of(1, 2, 3);
BuilderWithSet<Integer> instance =
BuilderWithSet.<Integer>builder().setList(integers).setT(23).build();
assertEquals(integers, instance.list());
assertEquals((Integer) 23, instance.t());
}
@AutoValue
public abstract static | Builder |
java | apache__kafka | clients/src/main/java/org/apache/kafka/common/requests/FetchRequest.java | {
"start": 2389,
"end": 5078
} | class ____ {
public final Uuid topicId;
public final long fetchOffset;
public final long logStartOffset;
public final int maxBytes;
public final Optional<Integer> currentLeaderEpoch;
public final Optional<Integer> lastFetchedEpoch;
public PartitionData(
Uuid topicId,
long fetchOffset,
long logStartOffset,
int maxBytes,
Optional<Integer> currentLeaderEpoch
) {
this(topicId, fetchOffset, logStartOffset, maxBytes, currentLeaderEpoch, Optional.empty());
}
public PartitionData(
Uuid topicId,
long fetchOffset,
long logStartOffset,
int maxBytes,
Optional<Integer> currentLeaderEpoch,
Optional<Integer> lastFetchedEpoch
) {
this.topicId = topicId;
this.fetchOffset = fetchOffset;
this.logStartOffset = logStartOffset;
this.maxBytes = maxBytes;
this.currentLeaderEpoch = currentLeaderEpoch;
this.lastFetchedEpoch = lastFetchedEpoch;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
PartitionData that = (PartitionData) o;
return Objects.equals(topicId, that.topicId) &&
fetchOffset == that.fetchOffset &&
logStartOffset == that.logStartOffset &&
maxBytes == that.maxBytes &&
Objects.equals(currentLeaderEpoch, that.currentLeaderEpoch) &&
Objects.equals(lastFetchedEpoch, that.lastFetchedEpoch);
}
@Override
public int hashCode() {
return Objects.hash(topicId, fetchOffset, logStartOffset, maxBytes, currentLeaderEpoch, lastFetchedEpoch);
}
@Override
public String toString() {
return "PartitionData(" +
"topicId=" + topicId +
", fetchOffset=" + fetchOffset +
", logStartOffset=" + logStartOffset +
", maxBytes=" + maxBytes +
", currentLeaderEpoch=" + currentLeaderEpoch +
", lastFetchedEpoch=" + lastFetchedEpoch +
')';
}
}
private static Optional<Integer> optionalEpoch(int rawEpochValue) {
if (rawEpochValue < 0) {
return Optional.empty();
} else {
return Optional.of(rawEpochValue);
}
}
// It is only used by KafkaRaftClient for downgrading the FetchRequest.
public static | PartitionData |
java | apache__camel | components/camel-thymeleaf/src/test/java/org/apache/camel/component/thymeleaf/ThymeleafClassLoaderResolverAllParamsTest.java | {
"start": 1565,
"end": 5284
} | class ____ extends ThymeleafAbstractBaseTest {
@Test
public void testThymeleaf() throws InterruptedException {
MockEndpoint mock = getMockEndpoint(MOCK_RESULT);
mock.expectedMessageCount(1);
mock.message(0).body().contains(THANK_YOU_FOR_YOUR_ORDER);
mock.message(0).body().endsWith(SPAZZ_TESTING_SERVICE);
mock.message(0).header(ThymeleafConstants.THYMELEAF_TEMPLATE).isNull();
mock.message(0).header(ThymeleafConstants.THYMELEAF_VARIABLE_MAP).isNull();
mock.message(0).header(FIRST_NAME).isEqualTo(JANE);
template.request(DIRECT_START, basicHeaderProcessor);
mock.assertIsSatisfied();
ThymeleafEndpoint thymeleafEndpoint = context.getEndpoint(
"thymeleaf:letter?allowContextMapAll=true&cacheable=false&cacheTimeToLive=500&checkExistence=true&encoding=UTF-8&order=1&prefix=WEB-INF/templates/&resolver=CLASS_LOADER&suffix=.html",
ThymeleafEndpoint.class);
assertAll("properties",
() -> assertNotNull(thymeleafEndpoint),
() -> assertTrue(thymeleafEndpoint.isAllowContextMapAll()),
() -> assertFalse(thymeleafEndpoint.getCacheable()),
() -> assertEquals(CACHE_TIME_TO_LIVE, thymeleafEndpoint.getCacheTimeToLive()),
() -> assertTrue(thymeleafEndpoint.getCheckExistence()),
() -> assertEquals(UTF_8_ENCODING, thymeleafEndpoint.getEncoding()),
() -> assertEquals(ExchangePattern.InOut, thymeleafEndpoint.getExchangePattern()),
() -> assertEquals(ORDER, thymeleafEndpoint.getOrder()),
() -> assertEquals(PREFIX_WEB_INF_TEMPLATES, thymeleafEndpoint.getPrefix()),
() -> assertEquals(ThymeleafResolverType.CLASS_LOADER, thymeleafEndpoint.getResolver()),
() -> assertEquals(HTML_SUFFIX, thymeleafEndpoint.getSuffix()),
() -> assertNotNull(thymeleafEndpoint.getTemplateEngine()),
() -> assertNull(thymeleafEndpoint.getTemplateMode()));
assertEquals(1, thymeleafEndpoint.getTemplateEngine().getTemplateResolvers().size());
ITemplateResolver resolver = thymeleafEndpoint.getTemplateEngine().getTemplateResolvers().stream().findFirst().get();
assertTrue(resolver instanceof ClassLoaderTemplateResolver);
ClassLoaderTemplateResolver templateResolver = (ClassLoaderTemplateResolver) resolver;
assertAll("templateResolver",
() -> assertFalse(templateResolver.isCacheable()),
() -> assertEquals(CACHE_TIME_TO_LIVE, templateResolver.getCacheTTLMs()),
() -> assertEquals(UTF_8_ENCODING, templateResolver.getCharacterEncoding()),
() -> assertTrue(templateResolver.getCheckExistence()),
() -> assertEquals(ORDER, templateResolver.getOrder()),
() -> assertEquals(PREFIX_WEB_INF_TEMPLATES, templateResolver.getPrefix()),
() -> assertEquals(HTML_SUFFIX, templateResolver.getSuffix()),
() -> assertEquals(TemplateMode.HTML, templateResolver.getTemplateMode()));
}
@Override
protected RouteBuilder createRouteBuilder() {
return new RouteBuilder() {
public void configure() {
from(DIRECT_START)
.setBody(simple(SPAZZ_TESTING_SERVICE))
.to("thymeleaf:letter?allowContextMapAll=true&cacheable=false&cacheTimeToLive=500&checkExistence=true&encoding=UTF-8&order=1&prefix=WEB-INF/templates/&resolver=CLASS_LOADER&suffix=.html")
.to(MOCK_RESULT);
}
};
}
}
| ThymeleafClassLoaderResolverAllParamsTest |
java | quarkusio__quarkus | integration-tests/websockets-next/src/test/java/io/quarkus/websockets/ChatTest.java | {
"start": 742,
"end": 2274
} | class ____ {
@TestHTTPResource("/chat/Tom")
URI uri;
@Test
public void testWebsocketChat() throws Exception {
CountDownLatch messageLatch = new CountDownLatch(2);
List<ChatMessage> messages = new CopyOnWriteArrayList<>();
Vertx vertx = Vertx.vertx();
WebSocketClient client = vertx.createWebSocketClient();
try {
client.connect(new WebSocketConnectOptions()
.setHost(uri.getHost())
.setPort(uri.getPort())
.setURI(uri.getPath()))
.onSuccess(
ws -> {
ws.textMessageHandler(m -> {
messages.add(Json.decodeValue(m, ChatMessage.class));
messageLatch.countDown();
});
ws.writeTextMessage(Json.encode(new ChatMessage(MessageType.CHAT_MESSAGE, "Tom", "Ping")));
});
assertTrue(messageLatch.await(10, TimeUnit.SECONDS), messageLatch.toString());
assertEquals(new ChatMessage(MessageType.USER_JOINED, "Tom", "Hello!"),
messages.get(0));
assertEquals(new ChatMessage(MessageType.CHAT_MESSAGE, "Tom", "Ping"),
messages.get(1));
} finally {
client.close().toCompletionStage().toCompletableFuture().get(5, TimeUnit.SECONDS);
vertx.close();
}
}
}
| ChatTest |
java | google__error-prone | core/src/test/java/com/google/errorprone/bugpatterns/MemoizeConstantVisitorStateLookupsTest.java | {
"start": 1871,
"end": 2213
} | class ____ {
public Test(VisitorState state) {
Name me = state.getName("Test");
}
}
""")
.addOutputLines(
"Test.java",
"""
import com.google.errorprone.VisitorState;
import com.google.errorprone.suppliers.Supplier;
import com.sun.tools.javac.util.Name;
| Test |
java | hibernate__hibernate-orm | hibernate-core/src/test/java/org/hibernate/orm/test/stateless/StatelessSessionVersioningTest.java | {
"start": 1135,
"end": 2072
} | class ____ {
@Test void testIdentity(SessionFactoryScope scope) {
Dialect dialect = scope.getMetadataImplementor().getDatabase().getDialect();
scope.inStatelessTransaction(s -> {
IdentityVersioned v = new IdentityVersioned();
s.insert(v);
assertEquals(0, v.version);
s.update(v);
assertEquals(1, v.version);
if ( !(dialect instanceof SQLServerDialect) ) {
//TODO: upsert() with IDENTITY not working on SQL Server
s.upsert(v);
assertEquals(2, v.version);
}
s.delete(v);
});
}
@Test void testUUID(SessionFactoryScope scope) {
Dialect dialect = scope.getMetadataImplementor().getDatabase().getDialect();
scope.inStatelessTransaction(s -> {
UUIDVersioned v = new UUIDVersioned();
s.insert(v);
assertEquals(0, v.version);
s.update(v);
assertEquals(1, v.version);
s.upsert(v);
assertEquals(2, v.version);
s.delete(v);
});
}
@Entity
static | StatelessSessionVersioningTest |
java | hibernate__hibernate-orm | hibernate-core/src/main/java/org/hibernate/dialect/function/xml/SQLServerXmlAggFunction.java | {
"start": 6006,
"end": 9096
} | class ____ extends AbstractSqlAstWalker {
private static final Set<String> POTENTIAL_SUBQUERY_FUNCTIONS = Set.of(
"xmlelement",
"xmlforest"
);
private final Set<String> columnQualifiers = new HashSet<>();
private boolean potentialSubquery;
public static Set<String> determineColumnQualifiers(SqlAstNode node) {
final ColumnQualifierCollectorSqlAstWalker walker = new ColumnQualifierCollectorSqlAstWalker();
node.accept( walker );
return walker.potentialSubquery ? walker.columnQualifiers : Set.of();
}
@Override
public void visitSelfRenderingExpression(SelfRenderingExpression expression) {
if ( expression instanceof FunctionExpression functionExpression
&& POTENTIAL_SUBQUERY_FUNCTIONS.contains( functionExpression.getFunctionName() ) ) {
potentialSubquery = true;
}
super.visitSelfRenderingExpression( expression );
}
@Override
public void visitColumnReference(ColumnReference columnReference) {
if ( columnReference.getQualifier() != null ) {
columnQualifiers.add( columnReference.getQualifier() );
}
}
}
@Override
public void render(
SqlAppender sqlAppender,
List<? extends SqlAstNode> sqlAstArguments,
Predicate filter,
List<SortSpecification> withinGroup,
ReturnableType<?> returnType,
SqlAstTranslator<?> translator) {
final boolean caseWrapper = filter != null && !filterClauseSupported( translator );
sqlAppender.appendSql( "cast(string_agg(" );
final SqlAstNode firstArg = sqlAstArguments.get( 0 );
final Expression arg;
if ( firstArg instanceof Distinct distinct ) {
sqlAppender.appendSql( "distinct " );
arg = distinct.getExpression();
}
else {
arg = (Expression) firstArg;
}
final boolean needsCast = ExpressionTypeHelper.isXml( arg );
if ( needsCast ) {
sqlAppender.appendSql( "cast(" );
}
if ( caseWrapper ) {
translator.getCurrentClauseStack().push( Clause.WHERE );
sqlAppender.appendSql( "case when " );
filter.accept( translator );
sqlAppender.appendSql( " then " );
arg.accept( translator );
sqlAppender.appendSql( " else null end" );
translator.getCurrentClauseStack().pop();
}
else {
arg.accept( translator );
}
if ( needsCast ) {
sqlAppender.appendSql( " as nvarchar(max))" );
}
sqlAppender.appendSql( ",'')" );
if ( withinGroup != null && !withinGroup.isEmpty() ) {
translator.getCurrentClauseStack().push( Clause.WITHIN_GROUP );
sqlAppender.appendSql( " within group (order by " );
withinGroup.get( 0 ).accept( translator );
for ( int i = 1; i < withinGroup.size(); i++ ) {
sqlAppender.appendSql( ',' );
withinGroup.get( i ).accept( translator );
}
sqlAppender.appendSql( ')' );
translator.getCurrentClauseStack().pop();
}
if ( !caseWrapper && filter != null ) {
translator.getCurrentClauseStack().push( Clause.WHERE );
sqlAppender.appendSql( " filter (where " );
filter.accept( translator );
sqlAppender.appendSql( ')' );
translator.getCurrentClauseStack().pop();
}
sqlAppender.appendSql( " as xml)" );
}
}
| ColumnQualifierCollectorSqlAstWalker |
java | apache__hadoop | hadoop-tools/hadoop-aws/src/test/java/org/apache/hadoop/fs/s3a/scale/ITestS3AHugeFilesArrayBlocks.java | {
"start": 1029,
"end": 1371
} | class ____ extends AbstractSTestS3AHugeFiles {
protected String getBlockOutputBufferName() {
return Constants.FAST_UPLOAD_BUFFER_ARRAY;
}
/**
* Skip this test suite when MPUS are not avaialable.
* @return false
*/
@Override
protected boolean requireMultipartUploads() {
return true;
}
}
| ITestS3AHugeFilesArrayBlocks |
java | mybatis__mybatis-3 | src/test/java/org/apache/ibatis/type/OffsetTimeTypeHandlerTest.java | {
"start": 993,
"end": 2946
} | class ____ extends BaseTypeHandlerTest {
private static final TypeHandler<OffsetTime> TYPE_HANDLER = new OffsetTimeTypeHandler();
private static final OffsetTime OFFSET_TIME = OffsetTime.now();
@Override
@Test
public void shouldSetParameter() throws Exception {
TYPE_HANDLER.setParameter(ps, 1, OFFSET_TIME, null);
verify(ps).setObject(1, OFFSET_TIME);
}
@Override
@Test
public void shouldGetResultFromResultSetByName() throws Exception {
when(rs.getObject("column", OffsetTime.class)).thenReturn(OFFSET_TIME);
assertEquals(OFFSET_TIME, TYPE_HANDLER.getResult(rs, "column"));
verify(rs, never()).wasNull();
}
@Override
@Test
public void shouldGetResultNullFromResultSetByName() throws Exception {
when(rs.getObject("column", OffsetTime.class)).thenReturn(null);
assertNull(TYPE_HANDLER.getResult(rs, "column"));
verify(rs, never()).wasNull();
}
@Override
@Test
public void shouldGetResultFromResultSetByPosition() throws Exception {
when(rs.getObject(1, OffsetTime.class)).thenReturn(OFFSET_TIME);
assertEquals(OFFSET_TIME, TYPE_HANDLER.getResult(rs, 1));
verify(rs, never()).wasNull();
}
@Override
@Test
public void shouldGetResultNullFromResultSetByPosition() throws Exception {
when(rs.getObject(1, OffsetTime.class)).thenReturn(null);
assertNull(TYPE_HANDLER.getResult(rs, 1));
verify(rs, never()).wasNull();
}
@Override
@Test
public void shouldGetResultFromCallableStatement() throws Exception {
when(cs.getObject(1, OffsetTime.class)).thenReturn(OFFSET_TIME);
assertEquals(OFFSET_TIME, TYPE_HANDLER.getResult(cs, 1));
verify(cs, never()).wasNull();
}
@Override
@Test
public void shouldGetResultNullFromCallableStatement() throws Exception {
when(cs.getObject(1, OffsetTime.class)).thenReturn(null);
assertNull(TYPE_HANDLER.getResult(cs, 1));
verify(cs, never()).wasNull();
}
}
| OffsetTimeTypeHandlerTest |
java | junit-team__junit5 | jupiter-tests/src/test/java/org/junit/jupiter/engine/NestedTestClassesTests.java | {
"start": 17559,
"end": 17658
} | class ____ {
@SuppressWarnings("InnerClassMayBeStatic")
abstract | AbstractBaseWithInnerClassTestCase |
java | apache__hadoop | hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-nodemanager/src/main/java/org/apache/hadoop/yarn/server/nodemanager/executor/ContainerReacquisitionContext.java | {
"start": 1297,
"end": 1465
} | class ____ {
private final Container container;
private final String user;
private final ContainerId containerId;
public static final | ContainerReacquisitionContext |
java | grpc__grpc-java | netty/src/main/java/io/grpc/netty/NettyServerHandler.java | {
"start": 30721,
"end": 37056
} | class ____ write the HTTP/2 DATA frame.
encoder().writeData(ctx, streamId, cmd.content(), 0, cmd.endStream(), promise);
}
}
/**
* Sends the response headers to the client.
*/
private void sendResponseHeaders(ChannelHandlerContext ctx, SendResponseHeadersCommand cmd,
ChannelPromise promise) throws Http2Exception {
try (TaskCloseable ignore = PerfMark.traceTask("NettyServerHandler.sendResponseHeaders")) {
PerfMark.attachTag(cmd.stream().tag());
PerfMark.linkIn(cmd.getLink());
int streamId = cmd.stream().id();
Http2Stream stream = connection().stream(streamId);
if (stream == null) {
streamGone(streamId, promise);
return;
}
if (cmd.endOfStream()) {
closeStreamWhenDone(promise, stream);
}
encoder().writeHeaders(ctx, streamId, cmd.headers(), 0, cmd.endOfStream(), promise);
}
}
private void cancelStream(ChannelHandlerContext ctx, CancelServerStreamCommand cmd,
ChannelPromise promise) {
try (TaskCloseable ignore = PerfMark.traceTask("NettyServerHandler.cancelStream")) {
PerfMark.attachTag(cmd.stream().tag());
PerfMark.linkIn(cmd.getLink());
// Notify the listener if we haven't already.
cmd.stream().transportReportStatus(cmd.reason());
// Now we need to decide how we're going to notify the peer that this stream is closed.
// If possible, it's nice to inform the peer _why_ this stream was cancelled by sending
// a structured headers frame.
if (shouldCloseStreamWithHeaders(cmd, connection())) {
Metadata md = new Metadata();
md.put(InternalStatus.CODE_KEY, cmd.reason());
if (cmd.reason().getDescription() != null) {
md.put(InternalStatus.MESSAGE_KEY, cmd.reason().getDescription());
}
Http2Headers headers = Utils.convertServerHeaders(md);
encoder().writeHeaders(
ctx, cmd.stream().id(), headers, /* padding = */ 0, /* endStream = */ true, promise);
} else {
// Terminate the stream.
encoder().writeRstStream(ctx, cmd.stream().id(), Http2Error.CANCEL.code(), promise);
}
}
}
// Determine whether a CancelServerStreamCommand should try to close the stream with a
// HEADERS or a RST_STREAM frame. The caller has some influence over this (they can
// configure cmd.wantsHeaders()). The state of the stream also has an influence: we
// only try to send HEADERS if the stream exists and hasn't already sent any headers.
private static boolean shouldCloseStreamWithHeaders(
CancelServerStreamCommand cmd, Http2Connection conn) {
if (!cmd.wantsHeaders()) {
return false;
}
Http2Stream stream = conn.stream(cmd.stream().id());
return stream != null && !stream.isHeadersSent();
}
private void gracefulClose(final ChannelHandlerContext ctx, final GracefulServerCloseCommand msg,
ChannelPromise promise) throws Exception {
// Ideally we'd adjust a pre-existing graceful shutdown's grace period to at least what is
// requested here. But that's an edge case and seems bug-prone.
if (gracefulShutdown == null) {
Long graceTimeInNanos = null;
if (msg.getGraceTimeUnit() != null) {
graceTimeInNanos = msg.getGraceTimeUnit().toNanos(msg.getGraceTime());
}
gracefulShutdown = new GracefulShutdown(msg.getGoAwayDebugString(), graceTimeInNanos);
gracefulShutdown.start(ctx);
}
promise.setSuccess();
}
private void forcefulClose(final ChannelHandlerContext ctx, final ForcefulCloseCommand msg,
ChannelPromise promise) throws Exception {
super.close(ctx, promise);
connection().forEachActiveStream(new Http2StreamVisitor() {
@Override
public boolean visit(Http2Stream stream) throws Http2Exception {
NettyServerStream.TransportState serverStream = serverStream(stream);
if (serverStream != null) {
try (TaskCloseable ignore = PerfMark.traceTask("NettyServerHandler.forcefulClose")) {
PerfMark.attachTag(serverStream.tag());
PerfMark.linkIn(msg.getLink());
serverStream.transportReportStatus(msg.getStatus());
resetStream(ctx, stream.id(), Http2Error.CANCEL.code(), ctx.newPromise());
}
}
stream.close();
return true;
}
});
}
private void respondWithHttpError(
ChannelHandlerContext ctx, int streamId, int code, Status.Code statusCode, String msg) {
respondWithHttpError(ctx, streamId, code, statusCode, msg, EmptyHttp2Headers.INSTANCE);
}
private void respondWithHttpError(
ChannelHandlerContext ctx, int streamId, int code, Status.Code statusCode, String msg,
Http2Headers extraHeaders) {
Metadata metadata = new Metadata();
metadata.put(InternalStatus.CODE_KEY, statusCode.toStatus());
metadata.put(InternalStatus.MESSAGE_KEY, msg);
byte[][] serialized = InternalMetadata.serialize(metadata);
Http2Headers headers = new DefaultHttp2Headers(true, serialized.length / 2)
.status("" + code)
.set(CONTENT_TYPE_HEADER, "text/plain; charset=utf-8");
for (int i = 0; i < serialized.length; i += 2) {
headers.add(new AsciiString(serialized[i], false), new AsciiString(serialized[i + 1], false));
}
headers.add(extraHeaders);
encoder().writeHeaders(ctx, streamId, headers, 0, false, ctx.newPromise());
ByteBuf msgBuf = ByteBufUtil.writeUtf8(ctx.alloc(), msg);
encoder().writeData(ctx, streamId, msgBuf, 0, true, ctx.newPromise());
}
private Http2Stream requireHttp2Stream(int streamId) {
Http2Stream stream = connection().stream(streamId);
if (stream == null) {
// This should never happen.
throw new AssertionError("Stream does not exist: " + streamId);
}
return stream;
}
/**
* Returns the server stream associated to the given HTTP/2 stream object.
*/
private NettyServerStream.TransportState serverStream(Http2Stream stream) {
return stream == null ? null : (NettyServerStream.TransportState) stream.getProperty(streamKey);
}
private Http2Exception newStreamException(int streamId, Throwable cause) {
return Http2Exception.streamError(
streamId, Http2Error.INTERNAL_ERROR, cause, Strings.nullToEmpty(cause.getMessage()));
}
private | to |
java | FasterXML__jackson-databind | src/test/java/tools/jackson/databind/deser/creators/PolymorphicPropsCreatorsTest.java | {
"start": 2535,
"end": 2858
} | class ____ {
public final static String ID = "id";
private String id;
@JsonCreator
public Animal113(@JsonProperty(ID) String id) {
this.id = id;
}
@JsonProperty(ID)
public String getId() {
return id;
}
}
public static | Animal113 |
java | elastic__elasticsearch | qa/lucene-index-compatibility/src/javaRestTest/java/org/elasticsearch/lucene/FullClusterRestartIndexCompatibilityTestCase.java | {
"start": 1404,
"end": 2390
} | class ____ extends AbstractIndexCompatibilityTestCase {
private final Version clusterVersion;
public FullClusterRestartIndexCompatibilityTestCase(@Name("cluster") Version clusterVersion) {
this.clusterVersion = clusterVersion;
}
@ParametersFactory
public static Iterable<Object[]> parameters() {
return Stream.of(VERSION_MINUS_2, VERSION_MINUS_1, CURRENT).map(v -> new Object[] { v }).toList();
}
@Override
protected void maybeUpgrade() throws Exception {
if (nodesVersions().values().stream().anyMatch(version -> version.before(clusterVersion))) {
cluster().upgradeToVersion(clusterVersion);
closeClients();
initClient();
}
assertThat(isFullyUpgradedTo(clusterVersion), equalTo(true));
}
/**
* Execute the test suite with the parameters provided by the {@link #parameters()} in version order.
*/
public static | FullClusterRestartIndexCompatibilityTestCase |
java | spring-projects__spring-boot | smoke-test/spring-boot-smoke-test-secure-jersey/src/main/java/smoketest/secure/jersey/SecurityConfiguration.java | {
"start": 1292,
"end": 2187
} | class ____ {
@Bean
@SuppressWarnings("deprecation")
public InMemoryUserDetailsManager inMemoryUserDetailsManager() {
return new InMemoryUserDetailsManager(
User.withDefaultPasswordEncoder()
.username("user")
.password("password")
.authorities("ROLE_USER")
.build(),
User.withDefaultPasswordEncoder()
.username("admin")
.password("admin")
.authorities("ROLE_ACTUATOR", "ROLE_USER")
.build());
}
@Bean
SecurityFilterChain configure(HttpSecurity http) {
http.authorizeHttpRequests((requests) -> {
requests.requestMatchers(EndpointRequest.to("health")).permitAll();
requests.requestMatchers(EndpointRequest.toAnyEndpoint().excluding(MappingsEndpoint.class))
.hasRole("ACTUATOR");
requests.requestMatchers("/**").hasRole("USER");
});
http.httpBasic(Customizer.withDefaults());
return http.build();
}
}
| SecurityConfiguration |
java | spring-projects__spring-framework | spring-test/src/test/java/org/springframework/test/context/support/DirtiesContextTestExecutionListenerTests.java | {
"start": 12516,
"end": 15980
} | class ____ {
@Test
void onTopLevelClassWithBeforeClass() throws Exception {
assertBeforeClass(BeforeAndAfterTestClassTopLevelClass.class);
}
@Test
void onNestedClassWithConfigOverriddenByDefaultWithAfterClass() throws Exception {
assertAfterClass(BeforeAndAfterTestClassTopLevelClass.ConfigOverriddenByDefault.class);
}
@Test
void onNestedClassWithInheritedConfigWithBeforeClass() throws Exception {
assertBeforeClass(BeforeAndAfterTestClassTopLevelClass.InheritedConfig.class);
}
@Test
void onNestedClassWithOverriddenConfigWithAfterClass() throws Exception {
assertAfterClass(BeforeAndAfterTestClassTopLevelClass.OverriddenConfig.class);
}
@Test
void onNestedClassWithInheritedConfigButOverriddenWithBeforeClass() throws Exception {
assertBeforeClass(BeforeAndAfterTestClassTopLevelClass.OverriddenConfig.InheritedConfigButOverridden.class);
}
}
private void assertBeforeMethod(Class<?> clazz) throws Exception {
BDDMockito.<Class<?>> given(testContext.getTestClass()).willReturn(clazz);
given(testContext.getTestMethod()).willReturn(clazz.getDeclaredMethod("test"));
beforeListener.beforeTestMethod(testContext);
afterListener.beforeTestMethod(testContext);
verify(testContext, times(1)).markApplicationContextDirty(EXHAUSTIVE);
afterListener.afterTestMethod(testContext);
beforeListener.afterTestMethod(testContext);
verify(testContext, times(1)).markApplicationContextDirty(EXHAUSTIVE);
}
private void assertAfterMethod(Class<?> clazz) throws Exception {
BDDMockito.<Class<?>> given(testContext.getTestClass()).willReturn(clazz);
given(testContext.getTestMethod()).willReturn(clazz.getDeclaredMethod("test"));
beforeListener.beforeTestMethod(testContext);
afterListener.beforeTestMethod(testContext);
verify(testContext, times(0)).markApplicationContextDirty(any(HierarchyMode.class));
afterListener.afterTestMethod(testContext);
beforeListener.afterTestMethod(testContext);
verify(testContext, times(1)).markApplicationContextDirty(EXHAUSTIVE);
}
private void assertBeforeClass(Class<?> clazz) throws Exception {
BDDMockito.<Class<?>> given(testContext.getTestClass()).willReturn(clazz);
beforeListener.beforeTestClass(testContext);
afterListener.beforeTestClass(testContext);
verify(testContext, times(1)).markApplicationContextDirty(EXHAUSTIVE);
afterListener.afterTestClass(testContext);
beforeListener.afterTestClass(testContext);
verify(testContext, times(1)).markApplicationContextDirty(EXHAUSTIVE);
}
private void assertAfterClass(Class<?> clazz) throws Exception {
BDDMockito.<Class<?>> given(testContext.getTestClass()).willReturn(clazz);
beforeListener.beforeTestClass(testContext);
afterListener.beforeTestClass(testContext);
verify(testContext, times(0)).markApplicationContextDirty(any(HierarchyMode.class));
afterListener.afterTestClass(testContext);
beforeListener.afterTestClass(testContext);
verify(testContext, times(1)).markApplicationContextDirty(EXHAUSTIVE);
}
// -------------------------------------------------------------------------
@DirtiesContext(methodMode = BEFORE_METHOD)
void dirtiesContextDeclaredLocallyWithBeforeMethodMode() {
}
@DirtiesContext
void dirtiesContextDeclaredLocallyWithAfterMethodMode() {
}
@MetaDirtyAfterMethod
void dirtiesContextDeclaredViaMetaAnnotationWithAfterMethodMode() {
}
@DirtiesContext
@Retention(RetentionPolicy.RUNTIME)
@ | NestedBeforeAndAfterTestClassTests |
java | apache__dubbo | dubbo-metrics/dubbo-tracing/src/main/java/org/apache/dubbo/tracing/DubboObservationRegistry.java | {
"start": 3051,
"end": 5380
} | class ____ external is existed.");
}
return;
}
if (logger.isDebugEnabled()) {
logger.debug("Tracing config is: " + JsonUtils.toJson(tracingConfig));
}
TracerProvider tracerProvider = TracerProviderFactory.getProvider(applicationModel, tracingConfig);
if (tracerProvider == null) {
logger.warn(
COMMON_NOT_FOUND_TRACER_DEPENDENCY,
"",
"",
"Can not found OpenTelemetry/Brave tracer dependencies, skip init ObservationRegistry.");
return;
}
// The real tracer will come from tracer implementation (OTel / Brave)
Tracer tracer = tracerProvider.getTracer();
// The real propagator will come from tracer implementation (OTel / Brave)
PropagatorProvider propagatorProvider = PropagatorProviderFactory.getPropagatorProvider();
Propagator propagator = propagatorProvider != null ? propagatorProvider.getPropagator() : Propagator.NOOP;
ObservationRegistry registry = ObservationRegistry.create();
registry.observationConfig()
// set up a first matching handler that creates spans - it comes from Micrometer Tracing.
// set up spans for sending and receiving data over the wire and a default one.
.observationHandler(new ObservationHandler.FirstMatchingCompositeObservationHandler(
new PropagatingSenderTracingObservationHandler<>(tracer, propagator),
new PropagatingReceiverTracingObservationHandler<>(tracer, propagator),
new DefaultTracingObservationHandler(tracer)))
.observationHandler(new ObservationHandler.FirstMatchingCompositeObservationHandler(
new DubboClientTracingObservationHandler<>(tracer),
new DubboServerTracingObservationHandler<>(tracer)));
if (MetricsSupportUtil.isSupportMetrics()) {
ObservationMeter.addMeterRegistry(registry, applicationModel);
}
applicationModel.getBeanFactory().registerBean(registry);
applicationModel.getBeanFactory().registerBean(tracer);
applicationModel.getBeanFactory().registerBean(propagator);
}
}
| from |
java | hibernate__hibernate-orm | hibernate-core/src/main/java/org/hibernate/query/sqm/tree/select/SqmSortSpecification.java | {
"start": 713,
"end": 4896
} | class ____ implements JpaOrder, SqmCacheable {
@SuppressWarnings("rawtypes")
private final SqmExpression sortExpression;
private final SortDirection sortOrder;
private final boolean ignoreCase;
private Nulls nullPrecedence;
public SqmSortSpecification(
@SuppressWarnings("rawtypes") SqmExpression sortExpression,
SortDirection sortOrder,
Nulls nullPrecedence) {
this( sortExpression, sortOrder, nullPrecedence, false );
}
public SqmSortSpecification(
SqmExpression<?> sortExpression,
SortDirection sortOrder,
Nulls nullPrecedence,
boolean ignoreCase) {
assert sortExpression != null;
assert sortOrder != null;
assert nullPrecedence != null;
this.sortExpression = sortExpression;
this.sortOrder = sortOrder;
this.nullPrecedence = nullPrecedence;
this.ignoreCase = ignoreCase;
}
/**
* @deprecated Use {@link SqmSortSpecification#SqmSortSpecification(SqmExpression, SortDirection, Nulls)} instead
*/
@Deprecated(since = "7", forRemoval = true)
public SqmSortSpecification(
@SuppressWarnings("rawtypes") SqmExpression sortExpression,
SortDirection sortOrder,
NullPrecedence nullPrecedence) {
this( sortExpression, sortOrder, nullPrecedence.getJpaValue() );
}
@SuppressWarnings("rawtypes")
public SqmSortSpecification(SqmExpression sortExpression) {
this( sortExpression, SortDirection.ASCENDING, Nulls.NONE );
}
@SuppressWarnings("rawtypes")
public SqmSortSpecification(SqmExpression sortExpression, SortDirection sortOrder) {
this( sortExpression, sortOrder, Nulls.NONE );
}
public SqmSortSpecification copy(SqmCopyContext context) {
return new SqmSortSpecification( sortExpression.copy( context ), sortOrder, nullPrecedence, ignoreCase );
}
public SqmExpression<?> getSortExpression() {
return sortExpression;
}
@Override
public SortDirection getSortDirection() {
return sortOrder;
}
public boolean isIgnoreCase() {
return ignoreCase;
}
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// JPA
@Override
public JpaOrder nullPrecedence(Nulls nullPrecedence) {
this.nullPrecedence = nullPrecedence;
return this;
}
@Override
public Nulls getNullPrecedence() {
return nullPrecedence;
}
@Override
public JpaOrder reverse() {
SortDirection newSortOrder = this.sortOrder == null ? SortDirection.DESCENDING : sortOrder.reverse();
return new SqmSortSpecification( sortExpression, newSortOrder, nullPrecedence, ignoreCase );
}
@Override
public JpaExpression<?> getExpression() {
return getSortExpression();
}
@Override
public boolean isAscending() {
return sortOrder == SortDirection.ASCENDING;
}
public void appendHqlString(StringBuilder sb, SqmRenderContext context) {
sortExpression.appendHqlString( sb, context );
if ( sortOrder == SortDirection.DESCENDING ) {
sb.append( " desc" );
if ( nullPrecedence != null ) {
if ( nullPrecedence == Nulls.FIRST ) {
sb.append( " nulls first" );
}
else {
sb.append( " nulls last" );
}
}
}
else if ( nullPrecedence != null ) {
sb.append( " asc" );
if ( nullPrecedence == Nulls.FIRST ) {
sb.append( " nulls first" );
}
else {
sb.append( " nulls last" );
}
}
}
@Override
public boolean equals(@Nullable Object other) {
return other instanceof SqmSortSpecification that
&& sortExpression.equals( that.sortExpression )
&& this.sortOrder == that.sortOrder
&& this.nullPrecedence == that.nullPrecedence;
}
@Override
public int hashCode() {
int result = sortExpression.hashCode();
result = 31 * result + sortOrder.hashCode();
result = 31 * result + Objects.hashCode( nullPrecedence );
return result;
}
@Override
public boolean isCompatible(Object other) {
return other instanceof SqmSortSpecification that
&& sortExpression.isCompatible( that.sortExpression )
&& this.sortOrder == that.sortOrder
&& this.nullPrecedence == that.nullPrecedence;
}
@Override
public int cacheHashCode() {
int result = sortExpression.cacheHashCode();
result = 31 * result + sortOrder.hashCode();
result = 31 * result + Objects.hashCode( nullPrecedence );
return result;
}
}
| SqmSortSpecification |
java | google__dagger | javatests/artifacts/hilt-android/simple/app/src/sharedTest/java/dagger/hilt/android/simple/ModuleTest.java | {
"start": 2804,
"end": 3147
} | class ____ {
@Provides
@TestQualifier(3)
String provideString() {
return "3";
}
}
/**
* Module which is used to test if abstract test modules get registered in the component
* correctly.
*/
@Module
@InstallIn(SingletonComponent.class)
public abstract static | StaticModuleNonStaticProvidesDefaultConstructor |
java | spring-projects__spring-framework | spring-webmvc/src/test/java/org/springframework/web/servlet/mvc/method/annotation/ServletAnnotationControllerHandlerMethodTests.java | {
"start": 128930,
"end": 129353
} | class ____ {
@RequestMapping("/myPath.do")
public void myHandle(@RequestParam(value = "id", defaultValue = "foo") String id,
@RequestParam(value = "otherId", defaultValue = "") String id2,
@RequestHeader(defaultValue = "bar") String header,
HttpServletResponse response) throws IOException {
response.getWriter().write(id + "-" + id2 + "-" + header);
}
}
@Controller
static | DefaultValueParamController |
java | apache__maven | compat/maven-resolver-provider/src/main/java/org/apache/maven/repository/internal/scopes/Maven4ScopeManagerConfiguration.java | {
"start": 2234,
"end": 9449
} | class ____ implements ScopeManagerConfiguration {
public static final Maven4ScopeManagerConfiguration INSTANCE = new Maven4ScopeManagerConfiguration();
public static final String RS_NONE = "none";
public static final String RS_MAIN_COMPILE = "main-compile";
public static final String RS_MAIN_COMPILE_PLUS_RUNTIME = "main-compilePlusRuntime";
public static final String RS_MAIN_RUNTIME = "main-runtime";
public static final String RS_MAIN_RUNTIME_PLUS_SYSTEM = "main-runtimePlusSystem";
public static final String RS_TEST_COMPILE = "test-compile";
public static final String RS_TEST_RUNTIME = "test-runtime";
private Maven4ScopeManagerConfiguration() {}
@Override
public String getId() {
return "Maven4";
}
@Override
public boolean isStrictDependencyScopes() {
return false;
}
@Override
public boolean isStrictResolutionScopes() {
return false;
}
@Override
public BuildScopeSource getBuildScopeSource() {
return new BuildScopeMatrixSource(
Arrays.asList(CommonBuilds.PROJECT_PATH_MAIN, CommonBuilds.PROJECT_PATH_TEST),
Arrays.asList(CommonBuilds.BUILD_PATH_COMPILE, CommonBuilds.BUILD_PATH_RUNTIME));
}
@Override
public Collection<org.eclipse.aether.scope.DependencyScope> buildDependencyScopes(
InternalScopeManager internalScopeManager) {
ArrayList<org.eclipse.aether.scope.DependencyScope> result = new ArrayList<>();
result.add(internalScopeManager.createDependencyScope(
DependencyScope.COMPILE.id(), DependencyScope.COMPILE.isTransitive(), all()));
result.add(internalScopeManager.createDependencyScope(
DependencyScope.RUNTIME.id(),
DependencyScope.RUNTIME.isTransitive(),
byBuildPath(CommonBuilds.BUILD_PATH_RUNTIME)));
result.add(internalScopeManager.createDependencyScope(
DependencyScope.PROVIDED.id(),
DependencyScope.PROVIDED.isTransitive(),
union(
byBuildPath(CommonBuilds.BUILD_PATH_COMPILE),
select(CommonBuilds.PROJECT_PATH_TEST, CommonBuilds.BUILD_PATH_RUNTIME))));
result.add(internalScopeManager.createDependencyScope(
DependencyScope.TEST.id(),
DependencyScope.TEST.isTransitive(),
byProjectPath(CommonBuilds.PROJECT_PATH_TEST)));
result.add(internalScopeManager.createDependencyScope(
DependencyScope.NONE.id(), DependencyScope.NONE.isTransitive(), Collections.emptySet()));
result.add(internalScopeManager.createDependencyScope(
DependencyScope.COMPILE_ONLY.id(),
DependencyScope.COMPILE_ONLY.isTransitive(),
singleton(CommonBuilds.PROJECT_PATH_MAIN, CommonBuilds.BUILD_PATH_COMPILE)));
result.add(internalScopeManager.createDependencyScope(
DependencyScope.TEST_RUNTIME.id(),
DependencyScope.TEST_RUNTIME.isTransitive(),
singleton(CommonBuilds.PROJECT_PATH_TEST, CommonBuilds.BUILD_PATH_RUNTIME)));
result.add(internalScopeManager.createDependencyScope(
DependencyScope.TEST_ONLY.id(),
DependencyScope.TEST_ONLY.isTransitive(),
singleton(CommonBuilds.PROJECT_PATH_TEST, CommonBuilds.BUILD_PATH_COMPILE)));
// system
result.add(internalScopeManager.createSystemDependencyScope(
DependencyScope.SYSTEM.id(),
DependencyScope.SYSTEM.isTransitive(),
all(),
MavenArtifactProperties.LOCAL_PATH));
// == sanity check
if (result.size() != org.apache.maven.api.DependencyScope.values().length - 1) { // sans "undefined"
throw new IllegalStateException("Maven4 API dependency scope mismatch");
}
return result;
}
@Override
public Collection<org.eclipse.aether.scope.ResolutionScope> buildResolutionScopes(
InternalScopeManager internalScopeManager) {
Collection<org.eclipse.aether.scope.DependencyScope> allDependencyScopes =
internalScopeManager.getDependencyScopeUniverse();
Collection<org.eclipse.aether.scope.DependencyScope> nonTransitiveDependencyScopes =
allDependencyScopes.stream().filter(s -> !s.isTransitive()).collect(Collectors.toSet());
org.eclipse.aether.scope.DependencyScope system = internalScopeManager
.getDependencyScope(DependencyScope.SYSTEM.id())
.orElse(null);
ArrayList<org.eclipse.aether.scope.ResolutionScope> result = new ArrayList<>();
result.add(internalScopeManager.createResolutionScope(
RS_NONE,
InternalScopeManager.Mode.REMOVE,
Collections.emptySet(),
Collections.emptySet(),
allDependencyScopes));
result.add(internalScopeManager.createResolutionScope(
RS_MAIN_COMPILE,
InternalScopeManager.Mode.ELIMINATE,
singleton(CommonBuilds.PROJECT_PATH_MAIN, CommonBuilds.BUILD_PATH_COMPILE),
Collections.singletonList(system),
nonTransitiveDependencyScopes));
result.add(internalScopeManager.createResolutionScope(
RS_MAIN_COMPILE_PLUS_RUNTIME,
InternalScopeManager.Mode.ELIMINATE,
byProjectPath(CommonBuilds.PROJECT_PATH_MAIN),
Collections.singletonList(system),
nonTransitiveDependencyScopes));
result.add(internalScopeManager.createResolutionScope(
RS_MAIN_RUNTIME,
InternalScopeManager.Mode.REMOVE,
singleton(CommonBuilds.PROJECT_PATH_MAIN, CommonBuilds.BUILD_PATH_RUNTIME),
Collections.emptySet(),
nonTransitiveDependencyScopes));
result.add(internalScopeManager.createResolutionScope(
RS_MAIN_RUNTIME_PLUS_SYSTEM,
InternalScopeManager.Mode.REMOVE,
singleton(CommonBuilds.PROJECT_PATH_MAIN, CommonBuilds.BUILD_PATH_RUNTIME),
Collections.singletonList(system),
nonTransitiveDependencyScopes));
result.add(internalScopeManager.createResolutionScope(
RS_TEST_COMPILE,
InternalScopeManager.Mode.ELIMINATE,
select(CommonBuilds.PROJECT_PATH_TEST, CommonBuilds.BUILD_PATH_COMPILE),
Collections.singletonList(system),
nonTransitiveDependencyScopes));
result.add(internalScopeManager.createResolutionScope(
RS_TEST_RUNTIME,
InternalScopeManager.Mode.ELIMINATE,
select(CommonBuilds.PROJECT_PATH_TEST, CommonBuilds.BUILD_PATH_RUNTIME),
Collections.singletonList(system),
nonTransitiveDependencyScopes));
return result;
}
// ===
public static void main(String... args) {
ScopeManagerDump.dump(Maven4ScopeManagerConfiguration.INSTANCE);
}
}
| Maven4ScopeManagerConfiguration |
java | apache__hadoop | hadoop-tools/hadoop-azure/src/main/java/org/apache/hadoop/fs/azurebfs/contracts/exceptions/HttpResponseException.java | {
"start": 1053,
"end": 1435
} | class ____ extends IOException {
private final HttpResponse httpResponse;
public HttpResponseException(final String s, final HttpResponse httpResponse) {
super(s);
Objects.requireNonNull(httpResponse, "httpResponse should be non-null");
this.httpResponse = httpResponse;
}
public HttpResponse getHttpResponse() {
return httpResponse;
}
}
| HttpResponseException |
java | quarkusio__quarkus | independent-projects/resteasy-reactive/common/runtime/src/main/java/org/jboss/resteasy/reactive/common/util/URLUtils.java | {
"start": 1045,
"end": 11202
} | class ____ {
private static final char PATH_SEPARATOR = '/';
private static final QueryStringParser QUERY_STRING_PARSER = new QueryStringParser('&', false) {
@Override
void handle(MultivaluedMap<String, String> exchange, String key, String value) {
exchange.add(key, value);
}
};
private static final QueryStringParser PATH_PARAM_PARSER = new QueryStringParser(';', true) {
@Override
void handle(MultivaluedMap<String, String> exchange, String key, String value) {
exchange.add(key, value);
}
};
// RFC-3986 (URI Generic Syntax) states:
// URI = scheme ":" hier-part [ "?" query ] [ "#" fragment ]
// scheme = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )
// "The scheme and path components are required, though the path may be empty (no characters)."
private static final Pattern SCHEME_PATTERN = Pattern.compile("^[a-zA-Z][a-zA-Z0-9+-.]*:.*");
private URLUtils() {
}
public static void parseQueryString(final String string, final MultivaluedMap<String, String> exchange,
final Charset charset, final boolean doDecode, int maxParameters) {
QUERY_STRING_PARSER.parse(string, exchange, charset, doDecode, maxParameters);
}
public static int parsePathParams(final String string, final MultivaluedMap<String, String> exchange, final Charset charset,
final boolean doDecode, int maxParameters) {
return PATH_PARAM_PARSER.parse(string, exchange, charset, doDecode, maxParameters);
}
/**
* Decodes a URL. If the decoding fails for any reason then an IllegalArgumentException will be thrown.
*
* @param s The string to decode
* @param enc The encoding
* @param decodeSlash If slash characters should be decoded
* @param buffer The string builder to use as a buffer.
* @return The decoded URL
*/
public static String decode(String s, Charset enc, boolean decodeSlash, StringBuilder buffer) {
return decode(s, enc, decodeSlash, true, buffer);
}
/**
* Decodes a URL. If the decoding fails for any reason then an IllegalArgumentException will be thrown.
*
* @param s The string to decode
* @param enc The encoding
* @param decodeSlash If slash characters should be decoded
* @param buffer The string builder to use as a buffer.
* @return The decoded URL
*/
public static String decode(String s, Charset enc, boolean decodeSlash, boolean formEncoding, StringBuilder buffer) {
if (buffer != null) {
buffer.setLength(0);
}
int numChars = s.length();
int i = 0;
while (i < numChars) {
char c = s.charAt(i);
if (c == '%' || c > 127 || c == '+') {
buffer = new StringBuilder();
buffer.append(s, 0, i);
/*
* Starting with this instance of a character
* that needs to be encoded, process all
* consecutive substrings of the form %xy. Each
* substring %xy will yield a byte. Convert all
* consecutive bytes obtained this way to whatever
* character(s) they represent in the provided
* encoding.
*
* Note that we need to decode the whole rest of the value, we can't just decode
* three characters. For multi code point characters there if the code point can be
* represented as an alphanumeric
*/
try {
// guess the size of the remaining bytes
// of remaining bytes
// this works for percent encoded characters,
// not so much for unencoded bytes
byte[] bytes = new byte[numChars - i + 1];
int pos = 0;
while ((i < numChars)) {
if (c == '%') {
// we need 2 more characters to decode the % construct
if ((i + 2) >= s.length()) {
throw failedToDecodeURL(s, enc, null);
}
char p1 = Character.toLowerCase(s.charAt(i + 1));
char p2 = Character.toLowerCase(s.charAt(i + 2));
if (!decodeSlash && ((p1 == '2' && p2 == 'f') || (p1 == '5' && p2 == 'c'))) {
if (pos + 2 >= bytes.length) {
bytes = expandBytes(bytes);
}
bytes[pos++] = (byte) c;
// should be copied with preserved upper/lower case
bytes[pos++] = (byte) s.charAt(i + 1);
bytes[pos++] = (byte) s.charAt(i + 2);
i += 3;
if (i < numChars) {
c = s.charAt(i);
}
continue;
}
int v = 0;
if (p1 >= '0' && p1 <= '9') {
v = (p1 - '0') << 4;
} else if (p1 >= 'a' && p1 <= 'f') {
v = (p1 - 'a' + 10) << 4;
} else {
throw failedToDecodeURL(s, enc, null);
}
if (p2 >= '0' && p2 <= '9') {
v += (p2 - '0');
} else if (p2 >= 'a' && p2 <= 'f') {
v += (p2 - 'a' + 10);
} else {
throw failedToDecodeURL(s, enc, null);
}
if (v < 0) {
throw failedToDecodeURL(s, enc, null);
}
if (pos == bytes.length) {
bytes = expandBytes(bytes);
}
bytes[pos++] = (byte) v;
i += 3;
if (i < numChars) {
c = s.charAt(i);
}
} else if (c == '+' && formEncoding) {
if (pos == bytes.length) {
bytes = expandBytes(bytes);
}
bytes[pos++] = (byte) ' ';
++i;
if (i < numChars) {
c = s.charAt(i);
}
} else {
if (pos == bytes.length) {
bytes = expandBytes(bytes);
}
++i;
if (c >> 8 != 0) {
bytes[pos++] = (byte) (c >> 8);
if (pos == bytes.length) {
bytes = expandBytes(bytes);
}
bytes[pos++] = (byte) c;
} else {
bytes[pos++] = (byte) c;
if (i < numChars) {
c = s.charAt(i);
}
}
}
}
String decoded = new String(bytes, 0, pos, enc);
buffer.append(decoded);
return buffer.toString();
} catch (NumberFormatException e) {
throw failedToDecodeURL(s, enc, e);
}
} else {
i++;
}
}
return s;
}
private static IllegalArgumentException failedToDecodeURL(String s, Charset enc, Throwable o) {
return new IllegalArgumentException("Failed to decode URL " + s + " to " + enc, o);
}
private static byte[] expandBytes(byte[] bytes) {
byte[] newBytes = new byte[bytes.length + 10];
System.arraycopy(bytes, 0, newBytes, 0, bytes.length);
return newBytes;
}
/**
* Extract path param names out of a JAX-RS path. Does not detect errors, but should
* be fast and correct if the input is correct.
*/
public static void parsePathParameters(String path, Set<String> pathParameters) {
if (path == null || path.isEmpty() || path.indexOf('{') == -1)
return;
int len = path.length();
int open = 0;
int startName = -1;
int endName = -1;
for (int i = 0; i < len; i++) {
switch (path.charAt(i)) {
case '{':
if (open == 0) {
startName = i + 1;
endName = -1;
}
open++;
break;
case '}':
// ignore extra closing brackets
if (open > 0) {
open--;
if (open == 0) {
// mark the end, unless we already marked it due to regex
if (endName == -1)
endName = i;
String pathParam = path.substring(startName, endName);
pathParameters.add(pathParam);
}
}
break;
case ':':
// mark the end of regex path param name
if (open == 1 && endName == -1)
endName = i;
break;
}
}
}
private abstract static | URLUtils |
java | hibernate__hibernate-orm | hibernate-core/src/test/java/org/hibernate/orm/test/mapping/fetch/subselect/SimpleEagerSubSelectFetchTests.java | {
"start": 4345,
"end": 5026
} | class ____ {
@Id
private Integer id;
private String name;
@OneToMany(mappedBy = "owner", fetch = FetchType.EAGER)
@Fetch(FetchMode.SUBSELECT)
private Set<Thing> things = new HashSet<>();
private Owner() {
}
public Owner(Integer id, String name) {
this.id = id;
this.name = name;
}
public Integer getId() {
return id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Set<Thing> getThings() {
return things;
}
public void setThings(Set<Thing> things) {
this.things = things;
}
}
@Entity(name = "Thing")
@Table(name = "t_sub_fetch_thing")
public static | Owner |
java | junit-team__junit5 | jupiter-tests/src/test/java/org/junit/jupiter/engine/discovery/predicates/IsTestMethodTests.java | {
"start": 5567,
"end": 5804
} | class ____ {
@Test
abstract void bogusAbstractTestMethod();
@Test
abstract int bogusAbstractNonVoidTestMethod();
}
@SuppressWarnings({ "JUnitMalformedDeclaration", "unused" })
private static | AbstractClassWithAbstractTestMethod |
java | quarkusio__quarkus | extensions/resteasy-reactive/rest-client/deployment/src/test/java/io/quarkus/rest/client/reactive/subresource/SubResourceTest.java | {
"start": 14889,
"end": 16246
} | class ____$SubClient312bda50cc002ce8e85608d3afaa6aa0963d20b3$$1$$1 implements HeaderFiller {
private static final Logger log = Logger.getLogger("io.quarkus.rest.client.reactive.subresource.SubResourceTest$SubClient312bda50cc002ce8e85608d3afaa6aa0963d20b3$$1$$1");
public void addHeaders(MultivaluedMap var1) {
if (!((Map)var1).containsKey("fromSubMethod")) {
String var2 = ((SubClient)(new SubResourceTest$SubClientf883748fb245dfc10599f70d1268b1940be6717f())).fillingMethod();
ArrayList var3 = new ArrayList();
((List)var3).add(var2);
((Map)var1).put("fromSubMethod", var3);
}
if (!((Map)var1).containsKey("fromRoot")) {
ArrayList var4 = new ArrayList();
((List)var4).add("headerValue");
((Map)var1).put("fromRoot", var4);
}
if (!((Map)var1).containsKey("overridable")) {
ArrayList var5 = new ArrayList();
((List)var5).add("SubClient");
((Map)var1).put("overridable", var5);
}
if (!((Map)var1).containsKey("fromRootMethod")) {
String var6 = ((RootClient)(new SubResourceTest$RootClient312bda50cc002ce8e85608d3afaa6aa0963d20b3())).fillingMethod();
ArrayList var7 = new ArrayList();
((List)var7).add(var6);
((Map)var1).put("fromRootMethod", var7);
}
}
}
*/
| SubResourceTest |
java | elastic__elasticsearch | server/src/main/java/org/elasticsearch/index/mapper/BlockLoader.java | {
"start": 30459,
"end": 30741
} | interface ____ extends Builder {
SingletonLongBuilder appendLong(long value);
SingletonLongBuilder appendLongs(long[] values, int from, int length);
}
/**
* Specialized builder for collecting dense arrays of double values.
*/
| SingletonLongBuilder |
java | elastic__elasticsearch | x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/parser/EsqlBaseParser.java | {
"start": 164518,
"end": 166405
} | class ____ extends ParserRuleContext {
public TerminalNode LP() { return getToken(EsqlBaseParser.LP, 0); }
public ForkSubQueryCommandContext forkSubQueryCommand() {
return getRuleContext(ForkSubQueryCommandContext.class,0);
}
public TerminalNode RP() { return getToken(EsqlBaseParser.RP, 0); }
@SuppressWarnings("this-escape")
public ForkSubQueryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_forkSubQuery; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EsqlBaseParserListener ) ((EsqlBaseParserListener)listener).enterForkSubQuery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EsqlBaseParserListener ) ((EsqlBaseParserListener)listener).exitForkSubQuery(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof EsqlBaseParserVisitor ) return ((EsqlBaseParserVisitor<? extends T>)visitor).visitForkSubQuery(this);
else return visitor.visitChildren(this);
}
}
public final ForkSubQueryContext forkSubQuery() throws RecognitionException {
ForkSubQueryContext _localctx = new ForkSubQueryContext(_ctx, getState());
enterRule(_localctx, 122, RULE_forkSubQuery);
try {
enterOuterAlt(_localctx, 1);
{
setState(592);
match(LP);
setState(593);
forkSubQueryCommand(0);
setState(594);
match(RP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static | ForkSubQueryContext |
java | quarkusio__quarkus | extensions/smallrye-fault-tolerance/deployment/src/test/java/io/quarkus/smallrye/faulttolerance/test/retry/backoff/ClassAndMethodBackoffService.java | {
"start": 341,
"end": 480
} | class ____ {
@FibonacciBackoff
public void hello() {
throw new IllegalArgumentException();
}
}
| ClassAndMethodBackoffService |
java | quarkusio__quarkus | extensions/reactive-routes/deployment/src/test/java/io/quarkus/vertx/web/DisabledUploadsTest.java | {
"start": 2567,
"end": 3043
} | class ____ {
@Route(path = "/vertx-web/upload", methods = HttpMethod.POST)
void upload(RoutingContext context) {
context.response().headers().set("Content-Type", "text/plain");
context.response().setChunked(true).setStatusCode(200);
for (FileUpload upload : context.fileUploads()) {
context.response().write(upload.uploadedFileName());
}
context.response().end();
}
}
}
| Routes |
java | micronaut-projects__micronaut-core | inject/src/main/java/io/micronaut/context/bind/ExecutableBeanContextBinder.java | {
"start": 1016,
"end": 1640
} | interface ____ extends ExecutableBinder<BeanContext> {
/**
* Binds a given {@link Executable} using the given registry and source object.
*
* @param target The target executable
* @param source The bean context
* @param <T> The executable target type
* @param <R> The executable return type
* @return The bound executable
* @throws UnsatisfiedArgumentException When the executable could not be satisfied
*/
<T, R> BoundExecutable<T, R> bind(
Executable<T, R> target,
BeanContext source
) throws UnsatisfiedArgumentException;
}
| ExecutableBeanContextBinder |
java | spring-projects__spring-framework | spring-context-support/src/main/java/org/springframework/scheduling/quartz/SchedulerContextAware.java | {
"start": 776,
"end": 1209
} | interface ____ be implemented by Spring-managed
* Quartz artifacts that need access to the SchedulerContext
* (without having natural access to it).
*
* <p>Currently only supported for custom JobFactory implementations
* that are passed in via Spring's SchedulerFactoryBean.
*
* @author Juergen Hoeller
* @author Chris Beams
* @since 2.0
* @see org.quartz.spi.JobFactory
* @see SchedulerFactoryBean#setJobFactory
*/
public | to |
java | elastic__elasticsearch | server/src/main/java/org/elasticsearch/action/admin/indices/stats/FieldUsageShardResponse.java | {
"start": 3175,
"end": 3711
} | class ____ {
static final String TRACKING_ID = "tracking_id";
static final String TRACKING_STARTED_AT_MILLIS = "tracking_started_at_millis";
static final String TRACKING_STARTED_AT = "tracking_started_at";
static final String STATS = "stats";
static final String ROUTING = "routing";
static final String STATE = "state";
static final String PRIMARY = "primary";
static final String NODE = "node";
static final String RELOCATING_NODE = "relocating_node";
}
}
| Fields |
java | apache__hadoop | hadoop-common-project/hadoop-registry/src/main/java/org/apache/hadoop/registry/client/impl/zk/RegistryBindingSource.java | {
"start": 1116,
"end": 1310
} | interface ____ {
/**
* Supply the binding information for this registry
* @return the binding information data
*/
BindingInformation supplyBindingInformation();
}
| RegistryBindingSource |
java | elastic__elasticsearch | modules/lang-painless/src/main/java/org/elasticsearch/painless/antlr/PainlessParser.java | {
"start": 60186,
"end": 62751
} | class ____ extends ParserRuleContext {
public TypeContext type() {
return getRuleContext(TypeContext.class, 0);
}
public List<TerminalNode> LBRACE() {
return getTokens(PainlessParser.LBRACE);
}
public TerminalNode LBRACE(int i) {
return getToken(PainlessParser.LBRACE, i);
}
public List<TerminalNode> RBRACE() {
return getTokens(PainlessParser.RBRACE);
}
public TerminalNode RBRACE(int i) {
return getToken(PainlessParser.RBRACE, i);
}
public DecltypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override
public int getRuleIndex() {
return RULE_decltype;
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if (visitor instanceof PainlessParserVisitor) return ((PainlessParserVisitor<? extends T>) visitor).visitDecltype(this);
else return visitor.visitChildren(this);
}
}
public final DecltypeContext decltype() throws RecognitionException {
DecltypeContext _localctx = new DecltypeContext(_ctx, getState());
enterRule(_localctx, 24, RULE_decltype);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(233);
type();
setState(238);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input, 20, _ctx);
while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) {
if (_alt == 1) {
{
{
setState(234);
match(LBRACE);
setState(235);
match(RBRACE);
}
}
}
setState(240);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input, 20, _ctx);
}
}
} catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
} finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static | DecltypeContext |
java | apache__kafka | clients/src/main/java/org/apache/kafka/common/security/authenticator/DefaultKafkaPrincipalBuilder.java | {
"start": 2395,
"end": 2443
} | class ____ can change without notice.
*/
public | and |
java | apache__thrift | lib/java/src/main/java/org/apache/thrift/transport/TSocket.java | {
"start": 1253,
"end": 7574
} | class ____ extends TIOStreamTransport implements SocketAddressProvider {
private static final Logger LOGGER = LoggerFactory.getLogger(TSocket.class.getName());
/** Wrapped Socket object */
private Socket socket_;
/** Remote host */
private String host_;
/** Remote port */
private int port_;
/** Socket timeout - read timeout on the socket */
private int socketTimeout_;
/** Connection timeout */
private int connectTimeout_;
/**
* Constructor that takes an already created socket.
*
* @param socket Already created socket object
* @throws TTransportException if there is an error setting up the streams
*/
public TSocket(Socket socket) throws TTransportException {
super(new TConfiguration());
socket_ = socket;
try {
socket_.setSoLinger(false, 0);
socket_.setTcpNoDelay(true);
socket_.setKeepAlive(true);
} catch (SocketException sx) {
LOGGER.warn("Could not configure socket.", sx);
}
if (isOpen()) {
try {
inputStream_ = new BufferedInputStream(socket_.getInputStream());
outputStream_ = new BufferedOutputStream(socket_.getOutputStream());
} catch (IOException iox) {
close();
throw new TTransportException(TTransportException.NOT_OPEN, iox);
}
}
}
/**
* Creates a new unconnected socket that will connect to the given host on the given port.
*
* @param config check config
* @param host Remote host
* @param port Remote port
*/
public TSocket(TConfiguration config, String host, int port) throws TTransportException {
this(config, host, port, 0);
}
/**
* Creates a new unconnected socket that will connect to the given host on the given port.
*
* @param host Remote host
* @param port Remote port
*/
public TSocket(String host, int port) throws TTransportException {
this(new TConfiguration(), host, port, 0);
}
/**
* Creates a new unconnected socket that will connect to the given host on the given port.
*
* @param host Remote host
* @param port Remote port
* @param timeout Socket timeout and connection timeout
*/
public TSocket(String host, int port, int timeout) throws TTransportException {
this(new TConfiguration(), host, port, timeout, timeout);
}
/**
* Creates a new unconnected socket that will connect to the given host on the given port.
*
* @param config check config
* @param host Remote host
* @param port Remote port
* @param timeout Socket timeout and connection timeout
*/
public TSocket(TConfiguration config, String host, int port, int timeout)
throws TTransportException {
this(config, host, port, timeout, timeout);
}
/**
* Creates a new unconnected socket that will connect to the given host on the given port, with a
* specific connection timeout and a specific socket timeout.
*
* @param config check config
* @param host Remote host
* @param port Remote port
* @param socketTimeout Socket timeout
* @param connectTimeout Connection timeout
*/
public TSocket(
TConfiguration config, String host, int port, int socketTimeout, int connectTimeout)
throws TTransportException {
super(config);
host_ = host;
port_ = port;
socketTimeout_ = socketTimeout;
connectTimeout_ = connectTimeout;
initSocket();
}
/** Initializes the socket object */
private void initSocket() {
socket_ = new Socket();
try {
socket_.setSoLinger(false, 0);
socket_.setTcpNoDelay(true);
socket_.setKeepAlive(true);
socket_.setSoTimeout(socketTimeout_);
} catch (SocketException sx) {
LOGGER.error("Could not configure socket.", sx);
}
}
/**
* Sets the socket timeout and connection timeout.
*
* @param timeout Milliseconds timeout
*/
public void setTimeout(int timeout) {
this.setConnectTimeout(timeout);
this.setSocketTimeout(timeout);
}
/**
* Sets the time after which the connection attempt will time out
*
* @param timeout Milliseconds timeout
*/
public void setConnectTimeout(int timeout) {
connectTimeout_ = timeout;
}
/**
* Sets the socket timeout
*
* @param timeout Milliseconds timeout
*/
public void setSocketTimeout(int timeout) {
socketTimeout_ = timeout;
try {
socket_.setSoTimeout(timeout);
} catch (SocketException sx) {
LOGGER.warn("Could not set socket timeout.", sx);
}
}
/** Returns a reference to the underlying socket. */
public Socket getSocket() {
if (socket_ == null) {
initSocket();
}
return socket_;
}
/** Checks whether the socket is connected. */
public boolean isOpen() {
if (socket_ == null) {
return false;
}
return socket_.isConnected();
}
/** Connects the socket, creating a new socket object if necessary. */
public void open() throws TTransportException {
if (isOpen()) {
throw new TTransportException(TTransportException.ALREADY_OPEN, "Socket already connected.");
}
if (host_ == null || host_.length() == 0) {
throw new TTransportException(TTransportException.NOT_OPEN, "Cannot open null host.");
}
if (port_ <= 0 || port_ > 65535) {
throw new TTransportException(TTransportException.NOT_OPEN, "Invalid port " + port_);
}
if (socket_ == null) {
initSocket();
}
try {
socket_.connect(new InetSocketAddress(host_, port_), connectTimeout_);
inputStream_ = new BufferedInputStream(socket_.getInputStream());
outputStream_ = new BufferedOutputStream(socket_.getOutputStream());
} catch (IOException iox) {
close();
throw new TTransportException(TTransportException.NOT_OPEN, iox);
}
}
/** Closes the socket. */
public void close() {
// Close the underlying streams
super.close();
// Close the socket
if (socket_ != null) {
try {
socket_.close();
} catch (IOException iox) {
LOGGER.warn("Could not close socket.", iox);
}
socket_ = null;
}
}
@Override
public SocketAddress getRemoteSocketAddress() {
return socket_.getRemoteSocketAddress();
}
@Override
public SocketAddress getLocalSocketAddress() {
return socket_.getLocalSocketAddress();
}
}
| TSocket |
java | resilience4j__resilience4j | resilience4j-core/src/main/java/io/github/resilience4j/core/ContextPropagator.java | {
"start": 1100,
"end": 8986
} | interface ____<T> {
public static final String CONTEXT_PROPAGATOR_LIST_SHOULD_BE_NON_NULL = "ContextPropagator list should be non null";
/**
* Retrieves value from the currently executing thread. This method should produce values (as
* Supplier) that needs to be propagated to new thread.
*
* @return a Supplier producing the value from current thread
*/
Supplier<Optional<T>> retrieve();
/**
* Copies value from the parent thread into new executing thread. This method is passed with the
* values received from method {@link ContextPropagator#retrieve()} in the parent thread.
*
* @return a Consumer to set values in new thread.
*/
Consumer<Optional<T>> copy();
/**
* CleanUp value before thread execution finish. This method is passed with the values received
* from method {@link ContextPropagator#retrieve()} in the parent thread.
*
* @return a Consumer to cleanUp values.
*/
Consumer<Optional<T>> clear();
/**
* Method decorates supplier to copy variables across thread boundary.
*
* @param propagator the instance of {@link ContextPropagator}
* @param supplier the supplier to be decorated
* @param <T> the type of variable that cross thread boundary
* @return decorated supplier of type T
*/
static <T> Supplier<T> decorateSupplier(ContextPropagator propagator,
Supplier<T> supplier) {
final Optional value = (Optional) propagator.retrieve().get();
return () -> {
try {
propagator.copy().accept(value);
return supplier.get();
} finally {
propagator.clear().accept(value);
}
};
}
/**
* Method decorates supplier to copy variables across thread boundary.
*
* @param propagators the instance of {@link ContextPropagator} should be non null.
* @param supplier the supplier to be decorated
* @param <T> the type of variable that cross thread boundary
* @return decorated supplier of type T
*/
static <T> Supplier<T> decorateSupplier(List<? extends ContextPropagator> propagators,
Supplier<T> supplier) {
Objects.requireNonNull(propagators, CONTEXT_PROPAGATOR_LIST_SHOULD_BE_NON_NULL);
//Create identity map of <ContextPropagator,Optional Supplier value>, if we have duplicate ContextPropagators then last one wins.
final Map<? extends ContextPropagator, Object> values = propagators.stream()
.collect(toMap(
p -> p, //key as ContextPropagator instance itself
p -> p.retrieve().get(), //Supplier Optional value
(first, second) -> second, //Merge function, this simply choose later value in key collision
HashMap::new)); //type of map
return () -> {
try {
values.forEach((p, v) -> p.copy().accept(v));
return supplier.get();
} finally {
values.forEach((p, v) -> p.clear().accept(v));
}
};
}
/**
* Method decorates callable to copy variables across thread boundary.
*
* @param propagator the instance of {@link ContextPropagator}
* @param callable the callable to be decorated
* @param <T> the type of variable that cross thread boundary
* @return decorated callable of type T
*/
static <T> Callable<T> decorateCallable(ContextPropagator propagator, Callable<T> callable) {
final Optional value = (Optional) propagator.retrieve().get();
return () -> {
try {
propagator.copy().accept(value);
return callable.call();
} finally {
propagator.clear().accept(value);
}
};
}
/**
* Method decorates callable to copy variables across thread boundary.
*
* @param propagators the instance of {@link ContextPropagator} should be non null.
* @param callable the callable to be decorated
* @param <T> the type of variable that cross thread boundary
* @return decorated callable of type T
*/
static <T> Callable<T> decorateCallable(List<? extends ContextPropagator> propagators,
Callable<T> callable) {
Objects.requireNonNull(propagators, CONTEXT_PROPAGATOR_LIST_SHOULD_BE_NON_NULL);
//Create identity map of <ContextPropagator,Optional Supplier value>, if we have duplicate ContextPropagators then last one wins.
final Map<? extends ContextPropagator, Object> values = propagators.stream()
.collect(toMap(
p -> p, //key as ContextPropagator instance itself
p -> p.retrieve().get(), //Supplier Optional value
(first, second) -> second, //Merge function, this simply choose later value in key collision
HashMap::new)); //type of map
return () -> {
try {
values.forEach((p, v) -> p.copy().accept(v));
return callable.call();
} finally {
values.forEach((p, v) -> p.clear().accept(v));
}
};
}
/**
* Method decorates runnable to copy variables across thread boundary.
*
* @param propagators the instance of {@link ContextPropagator}
* @param runnable the runnable to be decorated
* @param <T> the type of variable that cross thread boundary
* @return decorated supplier of type T
*/
static <T> Runnable decorateRunnable(List<? extends ContextPropagator> propagators,
Runnable runnable) {
Objects.requireNonNull(propagators, CONTEXT_PROPAGATOR_LIST_SHOULD_BE_NON_NULL);
//Create identity map of <ContextPropagator,Optional Supplier value>, if we have duplicate ContextPropagators then last one wins.
final Map<? extends ContextPropagator, Object> values = propagators.stream()
.collect(toMap(
p -> p, //key as ContextPropagator instance itself
p -> p.retrieve().get(), //Supplier Optional value
(first, second) -> second, //Merge function, this simply choose later value in key collision
HashMap::new)); //type of map
return () -> {
try {
values.forEach((p, v) -> p.copy().accept(v));
runnable.run();
} finally {
values.forEach((p, v) -> p.clear().accept(v));
}
};
}
/**
* Method decorates runnable to copy variables across thread boundary.
*
* @param propagator the instance of {@link ContextPropagator}
* @param runnable the runnable to be decorated
* @param <T> the type of variable that cross thread boundary
* @return decorated supplier of type T
*/
static <T> Runnable decorateRunnable(ContextPropagator propagator,
Runnable runnable) {
final Optional value = (Optional) propagator.retrieve().get();
return () -> {
try {
propagator.copy().accept(value);
runnable.run();
} finally {
propagator.clear().accept(value);
}
};
}
/**
* An empty context propagator.
*
* @param <T> type.
* @return an empty {@link ContextPropagator}
*/
static <T> ContextPropagator<T> empty() {
return new EmptyContextPropagator<>();
}
/**
* A convenient implementation of empty {@link ContextPropagator}
*
* @param <T> type of class.
*/
| ContextPropagator |
java | apache__flink | flink-table/flink-table-runtime/src/main/java/org/apache/flink/table/runtime/operators/window/async/tvf/common/AsyncStateWindowAggOperator.java | {
"start": 11457,
"end": 13923
} | class ____<W>
implements AsyncStateWindowProcessor.AsyncStateContext<W> {
private final Object operatorOwner;
private final MemoryManager memoryManager;
private final long memorySize;
private final InternalTimerService<W> timerService;
private final AsyncStateKeyContext asyncStateKeyContext;
private final Output<RowData> collector;
private final RuntimeContext runtimeContext;
private WindowProcessorAsyncStateContext(
Object operatorOwner,
MemoryManager memoryManager,
long memorySize,
InternalTimerService<W> timerService,
AsyncStateKeyContext asyncStateKeyContext,
Output<RowData> collector,
RuntimeContext runtimeContext) {
this.operatorOwner = operatorOwner;
this.memoryManager = memoryManager;
this.memorySize = memorySize;
this.timerService = timerService;
this.asyncStateKeyContext = checkNotNull(asyncStateKeyContext);
this.collector = checkNotNull(collector);
this.runtimeContext = checkNotNull(runtimeContext);
}
@Override
public Object getOperatorOwner() {
return operatorOwner;
}
@Override
public MemoryManager getMemoryManager() {
return memoryManager;
}
@Override
public long getMemorySize() {
return memorySize;
}
@Override
public AsyncStateKeyContext getAsyncKeyContext() {
return asyncStateKeyContext;
}
@Override
public InternalTimerService<W> getTimerService() {
return timerService;
}
@Override
public void output(RowData result) {
collector.collect(result);
}
@Override
public RuntimeContext getRuntimeContext() {
return runtimeContext;
}
}
// ------------------------------------------------------------------------------
// Visible For Testing
// ------------------------------------------------------------------------------
@VisibleForTesting
public Counter getNumLateRecordsDropped() {
return numLateRecordsDropped;
}
@VisibleForTesting
public Gauge<Long> getWatermarkLatency() {
return watermarkLatency;
}
}
| WindowProcessorAsyncStateContext |
java | quarkusio__quarkus | independent-projects/tools/registry-client/src/main/java/io/quarkus/registry/catalog/selection/OriginWithPreference.java | {
"start": 109,
"end": 795
} | class ____ {
private final ExtensionCatalog catalog;
private final OriginPreference preference;
public OriginWithPreference(ExtensionCatalog catalog, OriginPreference preference) {
this.catalog = catalog;
this.preference = preference;
}
public ExtensionCatalog getCatalog() {
return catalog;
}
public OriginPreference getPreference() {
return preference;
}
public boolean isSameAs(OriginWithPreference o) {
return preference.equals(o.preference);
}
public boolean canBeCombinedWith(OriginWithPreference o) {
return preference.canBeCombinedWith(o.getPreference());
}
}
| OriginWithPreference |
java | apache__hadoop | hadoop-hdfs-project/hadoop-hdfs-client/src/main/java/org/apache/hadoop/hdfs/web/resources/RecursiveParam.java | {
"start": 889,
"end": 1528
} | class ____ extends BooleanParam {
/** Parameter name. */
public static final String NAME = "recursive";
/** Default parameter value. */
public static final String DEFAULT = FALSE;
private static final Domain DOMAIN = new Domain(NAME);
/**
* Constructor.
* @param value the parameter value.
*/
public RecursiveParam(final Boolean value) {
super(DOMAIN, value);
}
/**
* Constructor.
* @param str a string representation of the parameter value.
*/
public RecursiveParam(final String str) {
this(DOMAIN.parse(str));
}
@Override
public String getName() {
return NAME;
}
}
| RecursiveParam |
java | apache__dubbo | dubbo-spring-boot-project/dubbo-spring-boot-autoconfigure/src/main/java/org/apache/dubbo/spring/boot/autoconfigure/observability/otel/OpenTelemetryAutoConfiguration.java | {
"start": 10679,
"end": 14029
} | class ____ {
private final DubboConfigurationProperties dubboConfigProperties;
BaggageConfiguration(DubboConfigurationProperties dubboConfigProperties) {
this.dubboConfigProperties = dubboConfigProperties;
}
@Bean
@ConditionalOnMissingBean
@ConditionalOnProperty(
prefix = ObservabilityUtils.DUBBO_TRACING_PROPAGATION,
name = "type",
havingValue = "W3C",
matchIfMissing = true)
@ConditionalOnClass(name = {"io.micrometer.tracing.otel.bridge.OtelCurrentTraceContext"})
io.opentelemetry.context.propagation.TextMapPropagator w3cTextMapPropagatorWithBaggage(
io.micrometer.tracing.otel.bridge.OtelCurrentTraceContext otelCurrentTraceContext) {
List<String> remoteFields =
this.dubboConfigProperties.getTracing().getBaggage().getRemoteFields();
return io.opentelemetry.context.propagation.TextMapPropagator.composite(
io.opentelemetry.api.trace.propagation.W3CTraceContextPropagator.getInstance(),
io.opentelemetry.api.baggage.propagation.W3CBaggagePropagator.getInstance(),
new io.micrometer.tracing.otel.propagation.BaggageTextMapPropagator(
remoteFields,
new io.micrometer.tracing.otel.bridge.OtelBaggageManager(
otelCurrentTraceContext, remoteFields, Collections.emptyList())));
}
@Bean
@ConditionalOnMissingBean
@ConditionalOnProperty(prefix = ObservabilityUtils.DUBBO_TRACING_PROPAGATION, name = "type", havingValue = "B3")
io.opentelemetry.context.propagation.TextMapPropagator b3BaggageTextMapPropagator(
io.micrometer.tracing.otel.bridge.OtelCurrentTraceContext otelCurrentTraceContext) {
List<String> remoteFields =
this.dubboConfigProperties.getTracing().getBaggage().getRemoteFields();
return io.opentelemetry.context.propagation.TextMapPropagator.composite(
io.opentelemetry.extension.trace.propagation.B3Propagator.injectingSingleHeader(),
new io.micrometer.tracing.otel.propagation.BaggageTextMapPropagator(
remoteFields,
new io.micrometer.tracing.otel.bridge.OtelBaggageManager(
otelCurrentTraceContext, remoteFields, Collections.emptyList())));
}
@Bean
@ConditionalOnMissingBean
@ConditionalOnProperty(
prefix = ObservabilityUtils.DUBBO_TRACING_BAGGAGE_CORRELATION,
name = "enabled",
matchIfMissing = true)
io.micrometer.tracing.otel.bridge.Slf4JBaggageEventListener otelSlf4JBaggageEventListener() {
return new io.micrometer.tracing.otel.bridge.Slf4JBaggageEventListener(this.dubboConfigProperties
.getTracing()
.getBaggage()
.getCorrelation()
.getFields());
}
}
@Configuration(proxyBeanMethods = false)
@ConditionalOnProperty(prefix = ObservabilityUtils.DUBBO_TRACING_BAGGAGE, name = "enabled", havingValue = "false")
static | BaggageConfiguration |
java | elastic__elasticsearch | modules/data-streams/src/test/java/org/elasticsearch/datastreams/lifecycle/DataStreamLifecycleErrorStoreTests.java | {
"start": 1306,
"end": 8983
} | class ____ extends ESTestCase {
private DataStreamLifecycleErrorStore errorStore;
private ProjectId projectId;
@Before
public void setupServices() {
errorStore = new DataStreamLifecycleErrorStore(System::currentTimeMillis);
projectId = randomProjectIdOrDefault();
}
public void testRecordAndRetrieveError() {
ErrorEntry existingRecordedError = errorStore.recordError(projectId, "test", new NullPointerException("testing"));
assertThat(existingRecordedError, is(nullValue()));
assertThat(errorStore.getError(projectId, "test"), is(notNullValue()));
assertThat(errorStore.getAllIndices(projectId).size(), is(1));
assertThat(errorStore.getAllIndices(projectId), hasItem("test"));
existingRecordedError = errorStore.recordError(projectId, "test", new IllegalStateException("bad state"));
assertThat(existingRecordedError, is(notNullValue()));
assertThat(existingRecordedError.error(), containsString("testing"));
}
public void testRetrieveAfterClear() {
errorStore.recordError(projectId, "test", new NullPointerException("testing"));
errorStore.clearStore();
assertThat(errorStore.getError(projectId, "test"), is(nullValue()));
}
public void testGetAllIndicesIsASnapshotViewOfTheStore() {
Stream.iterate(0, i -> i + 1)
.limit(5)
.forEach(i -> errorStore.recordError(projectId, "test" + i, new NullPointerException("testing")));
Set<String> initialAllIndices = errorStore.getAllIndices(projectId);
assertThat(initialAllIndices.size(), is(5));
assertThat(
initialAllIndices,
containsInAnyOrder(Stream.iterate(0, i -> i + 1).limit(5).map(i -> "test" + i).toArray(String[]::new))
);
// let's add some more items to the store and clear a couple of the initial ones
Stream.iterate(5, i -> i + 1)
.limit(5)
.forEach(i -> errorStore.recordError(projectId, "test" + i, new NullPointerException("testing")));
errorStore.clearRecordedError(projectId, "test0");
errorStore.clearRecordedError(projectId, "test1");
// the initial list should remain unchanged
assertThat(initialAllIndices.size(), is(5));
assertThat(
initialAllIndices,
containsInAnyOrder(Stream.iterate(0, i -> i + 1).limit(5).map(i -> "test" + i).toArray(String[]::new))
);
// calling getAllIndices again should reflect the latest state
assertThat(errorStore.getAllIndices(projectId).size(), is(8));
assertThat(
errorStore.getAllIndices(projectId),
containsInAnyOrder(Stream.iterate(2, i -> i + 1).limit(8).map(i -> "test" + i).toArray(String[]::new))
);
}
public void testRecordedErrorIsMaxOneThousandChars() {
NullPointerException exceptionWithLongMessage = new NullPointerException(randomAlphaOfLength(2000));
errorStore.recordError(projectId, "test", exceptionWithLongMessage);
assertThat(errorStore.getError(projectId, "test"), is(notNullValue()));
assertThat(errorStore.getError(projectId, "test").error().length(), is(MAX_ERROR_MESSAGE_LENGTH));
}
public void testGetFilteredEntries() {
IntStream.range(0, 20).forEach(i -> errorStore.recordError(projectId, "test20", new NullPointerException("testing")));
IntStream.range(0, 5).forEach(i -> errorStore.recordError(projectId, "test5", new NullPointerException("testing")));
{
List<DslErrorInfo> entries = errorStore.getErrorsInfo(entry -> entry.retryCount() > 7, 100);
assertThat(entries.size(), is(1));
assertThat(entries.getFirst().indexName(), is("test20"));
assertThat(entries.getFirst().projectId(), is(projectId));
}
{
List<DslErrorInfo> entries = errorStore.getErrorsInfo(entry -> entry.retryCount() > 7, 0);
assertThat(entries.size(), is(0));
}
{
List<DslErrorInfo> entries = errorStore.getErrorsInfo(entry -> entry.retryCount() > 50, 100);
assertThat(entries.size(), is(0));
}
{
List<DslErrorInfo> entries = errorStore.getErrorsInfo(entry -> entry.retryCount() > 2, 100);
assertThat(entries.size(), is(2));
assertThat(entries.get(0).indexName(), is("test20"));
assertThat(entries.get(0).projectId(), is(projectId));
assertThat(entries.get(1).indexName(), is("test5"));
assertThat(entries.get(1).projectId(), is(projectId));
}
}
public void testGetFilteredEntriesForMultipleProjects() {
ProjectId projectId1 = randomProjectIdOrDefault();
ProjectId projectId2 = randomUniqueProjectId();
IntStream.range(0, 20).forEach(i -> errorStore.recordError(projectId1, "test20", new NullPointerException("testing")));
IntStream.range(0, 5).forEach(i -> errorStore.recordError(projectId2, "test5", new NullPointerException("testing")));
{
List<DslErrorInfo> entries = errorStore.getErrorsInfo(entry -> entry.retryCount() > 7, 100);
assertThat(entries.size(), is(1));
assertThat(entries.getFirst().indexName(), is("test20"));
assertThat(entries.getFirst().projectId(), is(projectId1));
}
{
List<DslErrorInfo> entries = errorStore.getErrorsInfo(entry -> entry.retryCount() > 7, 0);
assertThat(entries.size(), is(0));
}
{
List<DslErrorInfo> entries = errorStore.getErrorsInfo(entry -> entry.retryCount() > 50, 100);
assertThat(entries.size(), is(0));
}
{
List<DslErrorInfo> entries = errorStore.getErrorsInfo(entry -> entry.retryCount() > 2, 100);
assertThat(entries.size(), is(2));
assertThat(entries.get(0).indexName(), is("test20"));
assertThat(entries.get(0).projectId(), is(projectId1));
assertThat(entries.get(1).indexName(), is("test5"));
assertThat(entries.get(1).projectId(), is(projectId2));
}
}
public void testTotalErrorCount() {
ProjectId projectId1 = randomProjectIdOrDefault();
ProjectId projectId2 = randomUniqueProjectId();
{
// empty store
assertThat(errorStore.getTotalErrorEntries(), is(0));
}
{
// single project multiple indices
IntStream.range(1, 20).forEach(i -> errorStore.recordError(projectId1, "index1", new NullPointerException("testing")));
IntStream.range(1, 5).forEach(i -> errorStore.recordError(projectId1, "index2", new NullPointerException("testing")));
IntStream.range(1, 5).forEach(i -> errorStore.recordError(projectId1, "index2", new IOException("testing")));
assertThat(errorStore.getTotalErrorEntries(), is(2));
}
{
// clear store
errorStore.clearStore();
assertThat(errorStore.getTotalErrorEntries(), is(0));
}
{
// multiple projects
IntStream.range(1, 20).forEach(i -> errorStore.recordError(projectId1, "index1", new NullPointerException("testing")));
IntStream.range(1, 5).forEach(i -> errorStore.recordError(projectId1, "index2", new IOException("testing")));
IntStream.range(1, 5).forEach(i -> errorStore.recordError(projectId2, "index1", new NullPointerException("testing")));
assertThat(errorStore.getTotalErrorEntries(), is(3));
}
}
}
| DataStreamLifecycleErrorStoreTests |
java | apache__camel | core/camel-core/src/test/java/org/apache/camel/processor/ProcessRefHashTest.java | {
"start": 973,
"end": 1666
} | class ____ extends ContextTestSupport {
@Test
public void testProcessRefHash() throws Exception {
getMockEndpoint("mock:result").expectedBodiesReceived("CamelCamel");
template.sendBody("direct:start", "Camel");
assertMockEndpointsSatisfied();
}
@Override
protected RouteBuilder createRouteBuilder() {
return new RouteBuilder() {
@Override
public void configure() {
context.getRegistry().bind("myEcho", new EchoProcessor());
from("direct:start")
.process("#myEcho")
.to("mock:result");
}
};
}
}
| ProcessRefHashTest |
java | grpc__grpc-java | core/src/test/java/io/grpc/internal/ManagedChannelImplBuilderTest.java | {
"start": 20285,
"end": 21351
} | class ____ implements Runnable {
@Override
public void run() {
ManagedChannelImplBuilder builder =
new ManagedChannelImplBuilder(
DUMMY_TARGET,
new UnsupportedClientTransportFactoryBuilder(),
new FixedPortProvider(DUMMY_PORT));
List<ClientInterceptor> effectiveInterceptors =
builder.getEffectiveInterceptors("unused:///");
assertThat(effectiveInterceptors).hasSize(2);
InternalConfiguratorRegistry.setConfigurators(Collections.emptyList());
assertThat(InternalConfiguratorRegistry.getConfigurators()).isEmpty();
assertThat(InternalConfiguratorRegistry.getConfiguratorsCallCountBeforeSet()).isEqualTo(1);
}
}
@Test
public void getEffectiveInterceptors_callsSetConfiguratorRegistry() throws Exception {
Class<?> runnable = classLoader.loadClass(StaticTestingClassLoaderCallsSet.class.getName());
((Runnable) runnable.getDeclaredConstructor().newInstance()).run();
}
// UsedReflectively
public static final | StaticTestingClassLoaderCallsGet |
java | apache__maven | its/core-it-suite/src/test/resources/mng-8750-new-scopes/deps/test-runtime-dep/src/main/java/org/apache/maven/its/mng8750/deps/TestRuntimeDep.java | {
"start": 859,
"end": 965
} | class ____ {
public String getMessage() {
return "Test runtime dependency";
}
}
| TestRuntimeDep |
java | spring-projects__spring-boot | smoke-test/spring-boot-smoke-test-actuator-log4j2/src/main/java/smoketest/actuator/log4j2/SampleActuatorLog4J2Application.java | {
"start": 813,
"end": 972
} | class ____ {
public static void main(String[] args) {
SpringApplication.run(SampleActuatorLog4J2Application.class, args);
}
}
| SampleActuatorLog4J2Application |
java | hibernate__hibernate-orm | hibernate-core/src/test/java/org/hibernate/orm/test/query/criteria/internal/hhh14197/Department.java | {
"start": 330,
"end": 754
} | class ____ extends AbstractPersistent {
private String name;
private Set<Employee> employees = new HashSet<>();
public String getName() {
return this.name;
}
public void setName(String name) {
this.name = name;
}
@OneToMany(mappedBy = "department")
public Set<Employee> getEmployees() {
return this.employees;
}
public void setEmployees(Set<Employee> employees) {
this.employees = employees;
}
}
| Department |
java | apache__flink | flink-table/flink-table-runtime/src/test/java/org/apache/flink/table/runtime/typeutils/LinkedListSerializerTest.java | {
"start": 1158,
"end": 2680
} | class ____ extends SerializerTestBase<LinkedList<Long>> {
@Override
protected TypeSerializer<LinkedList<Long>> createSerializer() {
return new LinkedListSerializer<>(LongSerializer.INSTANCE);
}
@Override
protected int getLength() {
return -1;
}
@SuppressWarnings("unchecked")
@Override
protected Class<LinkedList<Long>> getTypeClass() {
return (Class<LinkedList<Long>>) (Class<?>) LinkedList.class;
}
@SuppressWarnings({"rawtypes", "unchecked"})
@Override
protected LinkedList<Long>[] getTestData() {
final Random rnd = new Random(123654789);
// empty lists
final LinkedList<Long> list1 = new LinkedList<>();
// single element lists
final LinkedList<Long> list2 = new LinkedList<>();
list2.add(12345L);
// longer lists
final LinkedList<Long> list3 = new LinkedList<>();
for (int i = 0; i < rnd.nextInt(200); i++) {
list3.add(rnd.nextLong());
}
final LinkedList<Long> list4 = new LinkedList<>();
for (int i = 0; i < rnd.nextInt(200); i++) {
list4.add(rnd.nextLong());
}
// list with null values
final LinkedList<Long> list5 = new LinkedList<>();
for (int i = 0; i < rnd.nextInt(200); i++) {
list5.add(rnd.nextBoolean() ? null : rnd.nextLong());
}
return (LinkedList<Long>[]) new LinkedList[] {list1, list2, list3, list4, list5};
}
}
| LinkedListSerializerTest |
java | processing__processing4 | app/src/processing/app/laf/PdeScrollBarUI.java | {
"start": 1403,
"end": 4620
} | class ____ extends BasicScrollBarUI {
private final Dimension NONE = new Dimension();
final private String backgroundAttr;
final private String pressedAttr;
final private String rolloverAttr;
final private String enabledAttr;
private Color backgroundColor;
private Color pressedColor;
private Color rolloverColor;
private Color enabledColor;
public PdeScrollBarUI(String prefix) {
/*
this(prefix + ".scrollbar.color",
prefix + ".scrollbar.thumb.pressed.color",
prefix + ".scrollbar.thumb.rollover.color",
prefix + ".scrollbar.thumb.enabled.color");
}
public PdeScrollBarUI(String backgroundAttr, String pressedAttr,
String rolloverAttr, String enabledAttr) {
this.backgroundAttr = backgroundAttr;
this.pressedAttr = pressedAttr;
this.rolloverAttr = rolloverAttr;
this.enabledAttr = enabledAttr;
*/
this.backgroundAttr = prefix + ".color";
this.pressedAttr = prefix + ".thumb.pressed.color";
this.rolloverAttr = prefix + ".thumb.rollover.color";
this.enabledAttr = prefix + ".thumb.enabled.color";
}
public void updateTheme() {
backgroundColor = Theme.getColor(backgroundAttr);
pressedColor = Theme.getColor(pressedAttr);
rolloverColor = Theme.getColor(rolloverAttr);
enabledColor = Theme.getColor(enabledAttr);
}
@Override
protected JButton createDecreaseButton(int orientation) {
return new JButton() {
@Override
public Dimension getPreferredSize() {
return NONE;
}
};
}
@Override
protected JButton createIncreaseButton(int orientation) {
return new JButton() {
@Override
public Dimension getPreferredSize() {
return NONE;
}
};
}
/*
@Override
public void paint(Graphics g, JComponent c) {
// this takes care of the track as well as the corner notch
// where the horizontal and vertical scrollbars meet (edit: nope)
g.setColor(Theme.getColor("editor.scrollbar.color"));
g.fillRect(0, 0, c.getWidth(), c.getHeight());
super.paint(g, c);
}
*/
@Override
protected void paintTrack(Graphics g, JComponent c, Rectangle r) {
g.setColor(backgroundColor);
g.fillRect(0, 0, c.getWidth(), c.getHeight());
}
@Override
protected void paintThumb(Graphics g, JComponent c, Rectangle r) {
Graphics2D g2 = (Graphics2D) g.create();
// this can't really be necessary, can it?
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
Color color;
JScrollBar sb = (JScrollBar) c;
if (sb.isEnabled()) {
if (isDragging) {
color = pressedColor;
} else if (isThumbRollover()) {
color = rolloverColor;
} else {
color = enabledColor;
}
g2.setPaint(color);
int inset = 3;
int arc = Math.min(c.getWidth(), c.getHeight()) - inset*2;
g2.fillRoundRect(r.x + inset, r.y + inset, r.width - inset*2, r.height - inset*2, arc, arc);
g2.dispose();
}
}
@Override
protected void setThumbBounds(int x, int y, int width, int height) {
super.setThumbBounds(x, y, width, height);
scrollbar.repaint();
}
} | PdeScrollBarUI |
java | apache__camel | dsl/camel-componentdsl/src/generated/java/org/apache/camel/builder/component/dsl/TimerComponentBuilderFactory.java | {
"start": 1389,
"end": 1856
} | interface ____ {
/**
* Timer (camel-timer)
* Generate messages in specified intervals using java.util.Timer.
*
* Category: core,scheduling
* Since: 1.0
* Maven coordinates: org.apache.camel:camel-timer
*
* @return the dsl builder
*/
static TimerComponentBuilder timer() {
return new TimerComponentBuilderImpl();
}
/**
* Builder for the Timer component.
*/
| TimerComponentBuilderFactory |
java | lettuce-io__lettuce-core | src/main/java/io/lettuce/core/dynamic/ReactiveTypeAdapters.java | {
"start": 20854,
"end": 21303
} | enum ____ implements Function<Publisher<?>, io.reactivex.rxjava3.core.Single<?>> {
INSTANCE;
@Override
public io.reactivex.rxjava3.core.Single<?> apply(Publisher<?> source) {
return io.reactivex.rxjava3.core.Single.fromPublisher(source);
}
}
/**
* An adapter {@link Function} to adopt a {@link Publisher} to {@link io.reactivex.Completable}.
*/
public | PublisherToRxJava3SingleAdapter |
java | apache__camel | components/camel-thrift/src/test/java/org/apache/camel/component/thrift/generated/Calculator.java | {
"start": 59229,
"end": 65536
} | enum ____ implements org.apache.thrift.TFieldIdEnum {
;
private static final java.util.Map<java.lang.String, _Fields> byName
= new java.util.HashMap<java.lang.String, _Fields>();
static {
for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
byName.put(field.getFieldName(), field);
}
}
/**
* Find the _Fields constant that matches fieldId, or null if its not found.
*/
@org.apache.thrift.annotation.Nullable
public static _Fields findByThriftId(int fieldId) {
switch (fieldId) {
default:
return null;
}
}
/**
* Find the _Fields constant that matches fieldId, throwing an exception if it is not found.
*/
public static _Fields findByThriftIdOrThrow(int fieldId) {
_Fields fields = findByThriftId(fieldId);
if (fields == null)
throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
return fields;
}
/**
* Find the _Fields constant that matches name, or null if its not found.
*/
@org.apache.thrift.annotation.Nullable
public static _Fields findByName(java.lang.String name) {
return byName.get(name);
}
private final short _thriftId;
private final java.lang.String _fieldName;
_Fields(short thriftId, java.lang.String fieldName) {
_thriftId = thriftId;
_fieldName = fieldName;
}
@Override
public short getThriftFieldId() {
return _thriftId;
}
@Override
public java.lang.String getFieldName() {
return _fieldName;
}
}
public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
static {
java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap
= new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(ping_args.class, metaDataMap);
}
public ping_args() {
}
/**
* Performs a deep copy on <i>other</i>.
*/
public ping_args(ping_args other) {
}
@Override
public ping_args deepCopy() {
return new ping_args(this);
}
@Override
public void clear() {
}
@Override
public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
switch (field) {
}
}
@org.apache.thrift.annotation.Nullable
@Override
public java.lang.Object getFieldValue(_Fields field) {
switch (field) {
}
throw new java.lang.IllegalStateException();
}
/** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
@Override
public boolean isSet(_Fields field) {
if (field == null) {
throw new java.lang.IllegalArgumentException();
}
switch (field) {
}
throw new java.lang.IllegalStateException();
}
@Override
public boolean equals(java.lang.Object that) {
if (that instanceof ping_args)
return this.equals((ping_args) that);
return false;
}
public boolean equals(ping_args that) {
if (that == null)
return false;
if (this == that)
return true;
return true;
}
@Override
public int hashCode() {
int hashCode = 1;
return hashCode;
}
@Override
public int compareTo(ping_args other) {
if (!getClass().equals(other.getClass())) {
return getClass().getName().compareTo(other.getClass().getName());
}
int lastComparison = 0;
return 0;
}
@org.apache.thrift.annotation.Nullable
@Override
public _Fields fieldForId(int fieldId) {
return _Fields.findByThriftId(fieldId);
}
@Override
public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
scheme(iprot).read(iprot, this);
}
@Override
public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
scheme(oprot).write(oprot, this);
}
@Override
public java.lang.String toString() {
java.lang.StringBuilder sb = new java.lang.StringBuilder("ping_args(");
boolean first = true;
sb.append(")");
return sb.toString();
}
public void validate() throws org.apache.thrift.TException {
// check for required fields
// check for sub-struct validity
}
private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
try {
write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
} catch (org.apache.thrift.TException te) {
throw new java.io.IOException(te);
}
}
private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
try {
read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
} catch (org.apache.thrift.TException te) {
throw new java.io.IOException(te);
}
}
private static | _Fields |
java | hibernate__hibernate-orm | hibernate-core/src/test/java/org/hibernate/orm/test/mapping/basic/LongMappingTests.java | {
"start": 2732,
"end": 3115
} | class ____ {
@Id
Integer id;
//tag::basic-long-example-implicit[]
// these will both be mapped using BIGINT
Long wrapper;
long primitive;
//end::basic-long-example-implicit[]
public EntityOfLongs() {
}
public EntityOfLongs(Integer id, Long wrapper, long primitive) {
this.id = id;
this.wrapper = wrapper;
this.primitive = primitive;
}
}
}
| EntityOfLongs |
java | google__dagger | javatests/dagger/functional/assisted/AssistedFactoryWithQualifiedTypesTest.java | {
"start": 3878,
"end": 4494
} | interface ____ {
UnnecessaryQualifier create(@Assisted int i, @Assisted("") String str, double d);
}
@Test
public void testUnnecessaryQualifierFactory() {
String str = "str";
double d = 2.2;
int i = 11;
UnnecessaryQualifier unnecessaryQualifier =
DaggerAssistedFactoryWithQualifiedTypesTest_TestComponent.create()
.unnecessaryQualifierFactory()
.create(i, str, d);
assertThat(unnecessaryQualifier.str).isEqualTo(str);
assertThat(unnecessaryQualifier.d).isEqualTo(d);
assertThat(unnecessaryQualifier.i).isEqualTo(i);
}
}
| UnnecessaryQualifierFactory |
java | google__error-prone | core/src/main/java/com/google/errorprone/bugpatterns/BadImport.java | {
"start": 2769,
"end": 3005
} | class ____ extends BugChecker implements ImportTreeMatcher {
/**
* Class names which are bad as a direct import if they have an enclosing class.
*
* <p>The common factor for these names isn't just that they may be vague | BadImport |
java | google__error-prone | core/src/test/java/com/google/errorprone/bugpatterns/MockNotUsedInProductionTest.java | {
"start": 7447,
"end": 7889
} | class ____ {
@Mock private Test test;
public Object test() {
when(test.test()).thenCallRealMethod();
return null;
}
}
""")
.addOutputLines(
"Test.java",
"""
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import org.mockito.Mock;
| Test |
java | apache__hadoop | hadoop-yarn-project/hadoop-yarn/hadoop-yarn-common/src/main/java/org/apache/hadoop/yarn/api/protocolrecords/impl/pb/NodePublishVolumeRequestPBImpl.java | {
"start": 1558,
"end": 6379
} | class ____ extends
NodePublishVolumeRequest {
private CsiAdaptorProtos.NodePublishVolumeRequest.Builder builder;
public NodePublishVolumeRequestPBImpl() {
this.builder = CsiAdaptorProtos.NodePublishVolumeRequest.newBuilder();
}
public NodePublishVolumeRequestPBImpl(
CsiAdaptorProtos.NodePublishVolumeRequest request) {
this.builder = request.toBuilder();
}
public CsiAdaptorProtos.NodePublishVolumeRequest getProto() {
Preconditions.checkNotNull(builder);
return builder.build();
}
@Override
public void setVolumeId(String volumeId) {
Preconditions.checkNotNull(builder);
builder.setVolumeId(volumeId);
}
@Override
public String getVolumeId() {
Preconditions.checkNotNull(builder);
return builder.getVolumeId();
}
@Override
public void setReadonly(boolean readonly) {
Preconditions.checkNotNull(builder);
builder.setReadonly(readonly);
}
@Override
public boolean getReadOnly() {
Preconditions.checkNotNull(builder);
return builder.getReadonly();
}
@Override
public void setSecrets(Map<String, String> secrets) {
if (secrets != null) {
Preconditions.checkNotNull(builder);
for(Map.Entry<String, String> entry : secrets.entrySet()) {
YarnProtos.StringStringMapProto mapEntry =
YarnProtos.StringStringMapProto.newBuilder()
.setKey(entry.getKey())
.setValue(entry.getValue())
.build();
builder.addSecrets(mapEntry);
}
}
}
@Override
public Map<String, String> getSecrets() {
Preconditions.checkNotNull(builder);
return builder.getSecretsCount() > 0 ?
ProtoUtils.convertStringStringMapProtoListToMap(
builder.getSecretsList()) : ImmutableMap.of();
}
@Override
public String getTargetPath() {
Preconditions.checkNotNull(builder);
return builder.getTargetPath();
}
@Override
public void setStagingPath(String stagingPath) {
Preconditions.checkNotNull(builder);
builder.setStagingTargetPath(stagingPath);
}
@Override
public String getStagingPath() {
Preconditions.checkNotNull(builder);
return builder.getStagingTargetPath();
}
@Override
public void setPublishContext(Map<String, String> publishContext) {
if (publishContext != null) {
Preconditions.checkNotNull(builder);
for(Map.Entry<String, String> entry : publishContext.entrySet()) {
YarnProtos.StringStringMapProto mapEntry =
YarnProtos.StringStringMapProto.newBuilder()
.setKey(entry.getKey())
.setValue(entry.getValue())
.build();
builder.addPublishContext(mapEntry);
}
}
}
@Override
public Map<String, String> getPublishContext() {
Preconditions.checkNotNull(builder);
return builder.getPublishContextCount() > 0 ?
ProtoUtils.convertStringStringMapProtoListToMap(
builder.getPublishContextList()) : ImmutableMap.of();
}
@Override
public void setTargetPath(String targetPath) {
if (targetPath != null) {
Preconditions.checkNotNull(builder);
builder.setTargetPath(targetPath);
}
}
@Override
public void setVolumeCapability(
VolumeCapability capability) {
if (capability != null) {
CsiAdaptorProtos.VolumeCapability vc =
CsiAdaptorProtos.VolumeCapability.newBuilder()
.setAccessMode(CsiAdaptorProtos.VolumeCapability
.AccessMode.forNumber(
capability.getAccessMode().ordinal()))
.setVolumeType(CsiAdaptorProtos.VolumeCapability
.VolumeType.forNumber(capability.getVolumeType().ordinal()))
.addAllMountFlags(capability.getMountFlags())
.build();
builder.setVolumeCapability(vc);
}
}
@Override
public VolumeCapability getVolumeCapability() {
CsiAdaptorProtos.VolumeCapability cap0 = builder.getVolumeCapability();
if (builder.hasVolumeCapability()) {
return new VolumeCapability(
ValidateVolumeCapabilitiesRequest.AccessMode
.valueOf(cap0.getAccessMode().name()),
ValidateVolumeCapabilitiesRequest.VolumeType
.valueOf(cap0.getVolumeType().name()),
cap0.getMountFlagsList());
}
return null;
}
@Override
public String toString() {
return TextFormat.shortDebugString(getProto());
}
@Override
public int hashCode() {
return getProto().hashCode();
}
@Override
public boolean equals(Object other) {
if (other == null) {
return false;
}
if (other.getClass().isAssignableFrom(this.getClass())) {
return this.getProto().equals(this.getClass().cast(other).getProto());
}
return false;
}
}
| NodePublishVolumeRequestPBImpl |
java | hibernate__hibernate-orm | hibernate-core/src/test/java/org/hibernate/orm/test/hql/UpdateJoinedSubclassCorrelationTest.java | {
"start": 2639,
"end": 2845
} | class ____ extends Root {
private String name;
public SubRoot() { }
public SubRoot(Integer id, String name ) {
super(id);
this.name = name;
}
}
@Entity(name = "Detail")
public static | SubRoot |
java | apache__camel | core/camel-core-reifier/src/main/java/org/apache/camel/reifier/dataformat/TarFileDataFormatReifier.java | {
"start": 1030,
"end": 1701
} | class ____ extends DataFormatReifier<TarFileDataFormat> {
public TarFileDataFormatReifier(CamelContext camelContext, DataFormatDefinition definition) {
super(camelContext, (TarFileDataFormat) definition);
}
@Override
protected void prepareDataFormatConfig(Map<String, Object> properties) {
properties.put("usingIterator", definition.getUsingIterator());
properties.put("allowEmptyDirectory", definition.getAllowEmptyDirectory());
properties.put("preservePathElements", definition.getPreservePathElements());
properties.put("maxDecompressedSize", definition.getMaxDecompressedSize());
}
}
| TarFileDataFormatReifier |
java | apache__flink | flink-table/flink-table-runtime/src/main/java/org/apache/flink/table/runtime/operators/window/GlobalWindow.java | {
"start": 1805,
"end": 3651
} | class ____ extends TypeSerializerSingleton<GlobalWindow> {
private static final long serialVersionUID = 1L;
@Override
public boolean isImmutableType() {
return true;
}
@Override
public GlobalWindow createInstance() {
return GlobalWindow.INSTANCE;
}
@Override
public GlobalWindow copy(GlobalWindow from) {
return from;
}
@Override
public GlobalWindow copy(GlobalWindow from, GlobalWindow reuse) {
return from;
}
@Override
public int getLength() {
return Byte.BYTES;
}
@Override
public void serialize(GlobalWindow record, DataOutputView target) throws IOException {
target.writeByte(0);
}
@Override
public GlobalWindow deserialize(DataInputView source) throws IOException {
source.readByte();
return GlobalWindow.INSTANCE;
}
@Override
public GlobalWindow deserialize(GlobalWindow reuse, DataInputView source)
throws IOException {
source.readByte();
return GlobalWindow.INSTANCE;
}
@Override
public void copy(DataInputView source, DataOutputView target) throws IOException {
source.readByte();
target.writeByte(0);
}
// ------------------------------------------------------------------------
@Override
public TypeSerializerSnapshot<GlobalWindow> snapshotConfiguration() {
return new GlobalWindow.Serializer.GlobalWindowSerializerSnapshot();
}
/** Serializer configuration snapshot for compatibility and format evolution. */
@SuppressWarnings("WeakerAccess")
public static final | Serializer |
java | ReactiveX__RxJava | src/test/java/io/reactivex/rxjava3/tck/ConcatWithSingleTckTest.java | {
"start": 765,
"end": 1059
} | class ____ extends BaseTck<Integer> {
@Override
public Publisher<Integer> createPublisher(long elements) {
return
Flowable.range(1, Math.max(0, (int)elements - 1))
.concatWith(Single.just((int)elements))
;
}
}
| ConcatWithSingleTckTest |
java | elastic__elasticsearch | x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/AbstractInferenceServiceBaseTests.java | {
"start": 1235,
"end": 2480
} | class ____ extends InferenceServiceTestCase {
protected final TestConfiguration testConfiguration;
protected final MockWebServer webServer = new MockWebServer();
protected ThreadPool threadPool;
protected HttpClientManager clientManager;
protected AbstractInferenceServiceParameterizedTests.TestCase testCase;
@Override
@Before
public void setUp() throws Exception {
super.setUp();
webServer.start();
threadPool = createThreadPool(inferenceUtilityExecutors());
clientManager = HttpClientManager.create(Settings.EMPTY, threadPool, mockClusterServiceEmpty(), mock(ThrottlerManager.class));
}
@Override
@After
public void tearDown() throws Exception {
super.tearDown();
clientManager.close();
terminate(threadPool);
webServer.close();
}
public AbstractInferenceServiceBaseTests(TestConfiguration testConfiguration) {
this.testConfiguration = Objects.requireNonNull(testConfiguration);
}
/**
* Main configurations for the tests
*/
public record TestConfiguration(CommonConfig commonConfig, UpdateModelConfiguration updateModelConfiguration) {
public static | AbstractInferenceServiceBaseTests |
java | FasterXML__jackson-databind | src/main/java/tools/jackson/databind/ser/jdk/JDKArraySerializers.java | {
"start": 9191,
"end": 11489
} | class ____ extends StdSerializer<char[]>
{
public CharArraySerializer() { super(char[].class); }
@Override
public boolean isEmpty(SerializationContext prov, char[] value) {
return value.length == 0;
}
@Override
public void serialize(char[] value, JsonGenerator g, SerializationContext provider)
throws JacksonException
{
// [JACKSON-289] allows serializing as 'sparse' char array too:
if (provider.isEnabled(SerializationFeature.WRITE_CHAR_ARRAYS_AS_JSON_ARRAYS)) {
g.writeStartArray(value, value.length);
_writeArrayContents(g, value);
g.writeEndArray();
} else {
g.writeString(value, 0, value.length);
}
}
@Override
public void serializeWithType(char[] value, JsonGenerator g, SerializationContext ctxt,
TypeSerializer typeSer)
throws JacksonException
{
// [JACKSON-289] allows serializing as 'sparse' char array too:
final boolean asArray = ctxt.isEnabled(SerializationFeature.WRITE_CHAR_ARRAYS_AS_JSON_ARRAYS);
WritableTypeId typeIdDef;
if (asArray) {
typeIdDef = typeSer.writeTypePrefix(g, ctxt,
typeSer.typeId(value, JsonToken.START_ARRAY));
_writeArrayContents(g, value);
} else { // default is to write as simple String
typeIdDef = typeSer.writeTypePrefix(g, ctxt,
typeSer.typeId(value, JsonToken.VALUE_STRING));
g.writeString(value, 0, value.length);
}
typeSer.writeTypeSuffix(g, ctxt, typeIdDef);
}
private final void _writeArrayContents(JsonGenerator g, char[] value)
throws JacksonException
{
for (int i = 0, len = value.length; i < len; ++i) {
g.writeString(value, i, 1);
}
}
@Override
public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
{
visitArrayFormat(visitor, typeHint, JsonFormatTypes.STRING);
}
}
@JacksonStdImpl
public static | CharArraySerializer |
java | apache__spark | common/kvstore/src/main/java/org/apache/spark/util/kvstore/InMemoryStore.java | {
"start": 4837,
"end": 5051
} | class ____ the type "{@literal ConcurrentHashMap<Comparable<Object>, Boolean>}",
* which is used as a concurrent hashset for storing natural keys
* and the boolean value doesn't matter.
*/
private static | for |
java | dropwizard__dropwizard | dropwizard-servlets/src/test/java/io/dropwizard/servlets/assets/AssetServletTest.java | {
"start": 1952,
"end": 2195
} | class ____ extends AssetServlet {
private static final long serialVersionUID = 1L;
public RootAssetServlet() {
super("/", ROOT_SERVLET, null, StandardCharsets.UTF_8);
}
}
public static | RootAssetServlet |
java | quarkusio__quarkus | independent-projects/arc/processor/src/main/java/io/quarkus/arc/processor/ComponentsProviderGenerator.java | {
"start": 32108,
"end": 37423
} | class ____ {
* }
* </pre>
*
* To create an instance of {@code Foo}, instances of {@code Bar} and {@code Baz} must already exist.
* Further, to create an instance of {@code Bar}, an instance of {@code Baz} must already exist.
* The returned map contains this information in the reverse form:
*
* <pre>
* Foo -> []
* Bar -> [Foo]
* Baz -> [Foo, Bar]
* </pre>
*
* The key in this map is a bean and the value is a list of beans that depend on the key. In other words,
* the key is a dependency and the value is a list of its dependants.
*/
private Map<BeanInfo, List<BeanInfo>> initBeanDependencyMap(BeanDeployment beanDeployment) {
Function<BeanInfo, List<BeanInfo>> newArrayList = ignored -> new ArrayList<>();
// We need to iterate in a deterministic order for build time reproducibility
Map<BeanInfo, List<BeanInfo>> beanToInjections = new TreeMap<>(Reproducibility.BEAN_COMPARATOR);
for (BeanInfo bean : beanDeployment.getBeans()) {
if (bean.isProducer() && !bean.isStaticProducer()) {
// `static` producer doesn't depend on its declaring bean
beanToInjections.computeIfAbsent(bean.getDeclaringBean(), newArrayList).add(bean);
}
for (Injection injection : bean.getInjections()) {
for (InjectionPointInfo injectionPoint : injection.injectionPoints) {
if (!BuiltinBean.resolvesTo(injectionPoint)) {
beanToInjections.computeIfAbsent(injectionPoint.getResolvedBean(), newArrayList).add(bean);
}
}
}
if (bean.getDisposer() != null) {
for (InjectionPointInfo injectionPoint : bean.getDisposer().getInjection().injectionPoints) {
if (!BuiltinBean.resolvesTo(injectionPoint)) {
beanToInjections.computeIfAbsent(injectionPoint.getResolvedBean(), newArrayList).add(bean);
}
}
}
for (InterceptorInfo interceptor : bean.getBoundInterceptors()) {
beanToInjections.computeIfAbsent(interceptor, newArrayList).add(bean);
}
for (DecoratorInfo decorator : bean.getBoundDecorators()) {
beanToInjections.computeIfAbsent(decorator, newArrayList).add(bean);
}
}
// Also process interceptor and decorator injection points
for (InterceptorInfo interceptor : beanDeployment.getInterceptors()) {
for (Injection injection : interceptor.getInjections()) {
for (InjectionPointInfo injectionPoint : injection.injectionPoints) {
if (!BuiltinBean.resolvesTo(injectionPoint)) {
beanToInjections.computeIfAbsent(injectionPoint.getResolvedBean(), newArrayList)
.add(interceptor);
}
}
}
}
for (DecoratorInfo decorator : beanDeployment.getDecorators()) {
for (Injection injection : decorator.getInjections()) {
for (InjectionPointInfo injectionPoint : injection.injectionPoints) {
if (!injectionPoint.isDelegate() && !BuiltinBean.resolvesTo(injectionPoint)) {
beanToInjections.computeIfAbsent(injectionPoint.getResolvedBean(), newArrayList)
.add(decorator);
}
}
}
}
// Note that we do not have to process observer injection points because observers are always processed after all beans are ready
return beanToInjections;
}
private IllegalStateException circularDependenciesNotSupportedException(Map<BeanInfo, List<BeanInfo>> beanToInjections) {
StringBuilder msg = new StringBuilder("Circular dependencies not supported: \n");
for (Map.Entry<BeanInfo, List<BeanInfo>> e : beanToInjections.entrySet()) {
msg.append("\t ");
msg.append(e.getKey());
msg.append(" injected into: ");
msg.append(e.getValue()
.stream()
.map(BeanInfo::getBeanClass).map(Object::toString)
.collect(Collectors.joining(", ")));
msg.append("\n");
}
return new IllegalStateException(msg.toString());
}
private boolean addBeans(List<BeanInfo> list, Map<BeanInfo, List<BeanInfo>> dependencyMap,
Set<BeanInfo> processed, Predicate<BeanInfo> filter) {
boolean stuck = true;
for (Iterator<BeanInfo> iterator = dependencyMap.keySet().iterator(); iterator.hasNext();) {
BeanInfo bean = iterator.next();
if (filter.test(bean)) {
iterator.remove();
list.add(bean);
processed.add(bean);
stuck = false;
}
}
return stuck;
}
private boolean isDependency(BeanInfo bean, Map<BeanInfo, List<BeanInfo>> dependencyMap) {
for (List<BeanInfo> dependants : dependencyMap.values()) {
if (dependants.contains(bean)) {
return true;
}
}
return false;
}
}
| Baz |
java | elastic__elasticsearch | libs/entitlement/src/test/java/org/elasticsearch/entitlement/runtime/policy/FileAccessTreeComparisonTests.java | {
"start": 710,
"end": 3527
} | class ____ extends ESTestCase {
public void testPathOrderPosix() {
var pathComparator = new CaseSensitiveComparison('/').pathComparator();
// Unix-style
// Directories come BEFORE files; note that this differs from natural lexicographical order
assertThat(pathComparator.compare("/a/b", "/a.xml"), lessThan(0));
// Natural lexicographical order is respected in all the other cases
assertThat(pathComparator.compare("/a/b", "/a/b.txt"), lessThan(0));
assertThat(pathComparator.compare("/a/c", "/a/b.txt"), greaterThan(0));
assertThat(pathComparator.compare("/a/b", "/a/b/foo.txt"), lessThan(0));
// Inverted-windows style
// Directories come BEFORE files; note that this differs from natural lexicographical order
assertThat(pathComparator.compare("C:/a/b", "C:/a.xml"), lessThan(0));
// Natural lexicographical order is respected in all the other cases
assertThat(pathComparator.compare("C:/a/b", "C:/a/b.txt"), lessThan(0));
assertThat(pathComparator.compare("C:/a/c", "C:/a/b.txt"), greaterThan(0));
assertThat(pathComparator.compare("C:/a/b", "C:/a/b/foo.txt"), lessThan(0));
// "\" is a valid file name character on Posix, test we treat it like that
assertThat(pathComparator.compare("/a\\b", "/a/b.txt"), greaterThan(0));
}
public void testPathOrderWindows() {
var pathComparator = new CaseInsensitiveComparison('\\').pathComparator();
// Directories come BEFORE files; note that this differs from natural lexicographical order
assertThat(pathComparator.compare("C:\\a\\b", "C:\\a.xml"), lessThan(0));
// Natural lexicographical order is respected in all the other cases
assertThat(pathComparator.compare("C:\\a\\b", "C:\\a\\b.txt"), lessThan(0));
assertThat(pathComparator.compare("C:\\a\\b", "C:\\a\\b\\foo.txt"), lessThan(0));
assertThat(pathComparator.compare("C:\\a\\c", "C:\\a\\b.txt"), greaterThan(0));
}
public void testPathOrderingSpecialCharacters() {
var s = randomFrom('/', '\\');
var pathComparator = (randomBoolean() ? new CaseInsensitiveComparison(s) : new CaseSensitiveComparison(s)).pathComparator();
assertThat(pathComparator.compare("aa\uD801\uDC28", "aa\uD801\uDC28"), is(0));
assertThat(pathComparator.compare("aa\uD801\uDC28", "aa\uD801\uDC28a"), lessThan(0));
// Similarly to the other tests, we assert that Directories come BEFORE files, even when names are special characters
assertThat(pathComparator.compare(s + "\uD801\uDC28" + s + "b", s + "\uD801\uDC28.xml"), lessThan(0));
assertThat(pathComparator.compare(s + "\uD801\uDC28" + s + "b", s + "b.xml"), greaterThan(0));
}
}
| FileAccessTreeComparisonTests |
java | FasterXML__jackson-databind | src/test/java/tools/jackson/databind/contextual/ContextualSerializationTest.java | {
"start": 1794,
"end": 2018
} | class ____
{
@Prefix("wrapped:")
public ContextualBean wrapped;
public ContextualBeanWrapper(String s) {
wrapped = new ContextualBean(s);
}
}
static | ContextualBeanWrapper |
java | apache__flink | flink-table/flink-sql-gateway/src/test/java/org/apache/flink/table/gateway/rest/SqlGatewayRestEndpointITCase.java | {
"start": 17724,
"end": 18258
} | class ____ implements ResponseBody {
private final String status;
@JsonCreator
public TestResponse(@JsonProperty("status") String status) {
this.status = status;
}
public String getStatus() {
return status;
}
}
// --------------------------------------------------------------------------------------------
// Headers
// --------------------------------------------------------------------------------------------
private static | TestResponse |
java | google__error-prone | core/src/main/java/com/google/errorprone/bugpatterns/nullness/RedundantNullCheck.java | {
"start": 2520,
"end": 6572
} | class ____ extends BugChecker
implements BinaryTreeMatcher, MethodInvocationTreeMatcher {
private static final Matcher<ExpressionTree> OBJECTS_REQUIRE_NON_NULL =
staticMethod().onClass("java.util.Objects").named("requireNonNull");
private final boolean checkRequireNonNull;
@Inject
RedundantNullCheck(ErrorProneFlags flags) {
this.checkRequireNonNull =
flags.getBoolean("RedundantNullCheck:CheckRequireNonNull").orElse(false);
}
@Override
public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
if (!checkRequireNonNull) {
return NO_MATCH;
}
if (!OBJECTS_REQUIRE_NON_NULL.matches(tree, state)) {
return NO_MATCH;
}
ExpressionTree arg = tree.getArguments().get(0);
Symbol symbol = ASTHelpers.getSymbol(arg);
if (symbol instanceof VarSymbol varSymbol && !isEffectivelyNullable(varSymbol, state)) {
return describeMatch(tree);
}
if (symbol instanceof MethodSymbol methodSymbol
&& !isEffectivelyNullable(methodSymbol, state)) {
return describeMatch(tree);
}
return NO_MATCH;
}
@Override
public Description matchBinary(BinaryTree tree, VisitorState state) {
NullCheck nullCheck = NullnessUtils.getNullCheck(tree);
if (nullCheck == null) {
return NO_MATCH;
}
VarSymbol varSymbol = nullCheck.varSymbolButUsuallyPreferBareIdentifier();
if (varSymbol != null && !isEffectivelyNullable(varSymbol, state)) {
return describeMatch(tree);
}
MethodSymbol methodSymbol = nullCheck.methodSymbol();
if (methodSymbol != null && !isEffectivelyNullable(methodSymbol, state)) {
return describeMatch(tree);
}
return NO_MATCH;
}
private static boolean isEffectivelyNullable(VarSymbol varSymbol, VisitorState state) {
boolean isLocalOrResourceVariable =
varSymbol.getKind() == ElementKind.LOCAL_VARIABLE
|| varSymbol.getKind() == ElementKind.RESOURCE_VARIABLE;
if (!isLocalOrResourceVariable) {
Optional<Nullness> varNullness = NullnessAnnotations.fromAnnotationsOn(varSymbol);
if (varNullness.isPresent()) {
return varNullness.get() == Nullness.NULLABLE;
}
}
if (varSymbol.asType().getKind() == TYPEVAR) {
return true;
}
VariableTree varDecl = NullnessUtils.findDeclaration(state, varSymbol);
if (varSymbol.getKind() == ElementKind.PARAMETER && hasImplicitType(varDecl, state)) {
return true;
}
if (isLocalOrResourceVariable) {
if (varDecl.getInitializer() == null) {
return true;
}
if (!isConsideredFinal(varSymbol)) {
return true;
}
Tree initializer = varDecl.getInitializer();
if (initializer instanceof MethodInvocationTree methodInvocation) {
MethodSymbol methodSymbol = ASTHelpers.getSymbol(methodInvocation);
return methodSymbol == null || isEffectivelyNullable(methodSymbol, state);
} else if (initializer instanceof LiteralTree) {
return initializer.getKind() == Tree.Kind.NULL_LITERAL;
}
return true;
}
return !NullnessUtils.isInNullMarkedScope(varSymbol, state);
}
private static boolean isEffectivelyNullable(MethodSymbol methodSymbol, VisitorState state) {
Optional<Nullness> returnTypeNullness = NullnessAnnotations.fromAnnotationsOn(methodSymbol);
if (returnTypeNullness.isPresent()) {
// Explicit @Nullable or @NonNull on the return type
return returnTypeNullness.get() == Nullness.NULLABLE;
}
if (methodSymbol.isConstructor()) {
return false;
}
if (methodSymbol.getReturnType().getKind() == TYPEVAR) {
return true;
}
// No explicit annotation on return type.
// Default based on the null-marked status of the method's defining scope.
// If the method's defining scope is NOT @NullMarked (or is @NullUnmarked),
// its unannotated return type is effectively nullable.
return !NullnessUtils.isInNullMarkedScope(methodSymbol, state);
}
}
| RedundantNullCheck |
java | quarkusio__quarkus | extensions/smallrye-jwt/deployment/src/test/java/io/quarkus/jwt/test/DefaultGroupsSignEncryptConfigSourceUnitTest.java | {
"start": 344,
"end": 1536
} | class ____ {
private static Class<?>[] testClasses = {
DefaultGroupsEndpoint.class,
TestConfigSource.class
};
@RegisterExtension
static final QuarkusUnitTest config = new QuarkusUnitTest()
.withApplicationRoot((jar) -> jar
.addClasses(testClasses)
.addAsServiceProvider(ConfigSource.class, TestConfigSource.class)
.addAsResource("publicKey.pem")
.addAsResource("privateKey.pem")
.addAsResource("applicationSignEncryptConfigSource.properties", "application.properties"));
/**
* Validate a request with MP-JWT without a 'groups' claim is successful
* due to the default value being provided in the configuration
*
*/
@Test
public void echoGroups() {
String token = Jwt.issuer("https://server.example.com").upn("upn").innerSign()
.encrypt();
RestAssured.given().auth()
.oauth2(token)
.get("/endp/echo")
.then().assertThat().statusCode(200)
.body(equalTo("User"));
}
}
| DefaultGroupsSignEncryptConfigSourceUnitTest |
java | apache__kafka | clients/src/test/java/org/apache/kafka/clients/admin/internals/AdminMetadataManagerTest.java | {
"start": 1632,
"end": 7535
} | class ____ {
private final MockTime time = new MockTime();
private final LogContext logContext = new LogContext();
private final long refreshBackoffMs = 100;
private final long metadataExpireMs = 60000;
private final AdminMetadataManager mgr = new AdminMetadataManager(
logContext, refreshBackoffMs, metadataExpireMs, false);
@ParameterizedTest
@ValueSource(booleans = {false, true})
public void testSetUsingBootstrapControllers(boolean usingBootstrapControllers) {
AdminMetadataManager manager = new AdminMetadataManager(
logContext, refreshBackoffMs, metadataExpireMs, usingBootstrapControllers);
assertEquals(usingBootstrapControllers, manager.usingBootstrapControllers());
}
@Test
public void testMetadataReady() {
// Metadata is not ready on initialization
assertFalse(mgr.isReady());
assertEquals(0, mgr.metadataFetchDelayMs(time.milliseconds()));
// Metadata is not ready when bootstrap servers are set
mgr.update(Cluster.bootstrap(Collections.singletonList(new InetSocketAddress("localhost", 9999))),
time.milliseconds());
assertFalse(mgr.isReady());
assertEquals(0, mgr.metadataFetchDelayMs(time.milliseconds()));
mgr.update(mockCluster(), time.milliseconds());
assertTrue(mgr.isReady());
assertEquals(metadataExpireMs, mgr.metadataFetchDelayMs(time.milliseconds()));
time.sleep(metadataExpireMs);
assertEquals(0, mgr.metadataFetchDelayMs(time.milliseconds()));
}
@Test
public void testMetadataRefreshBackoff() {
mgr.transitionToUpdatePending(time.milliseconds());
assertEquals(Long.MAX_VALUE, mgr.metadataFetchDelayMs(time.milliseconds()));
mgr.updateFailed(new RuntimeException());
assertEquals(refreshBackoffMs, mgr.metadataFetchDelayMs(time.milliseconds()));
// Even if we explicitly request an update, the backoff should be respected
mgr.requestUpdate();
assertEquals(refreshBackoffMs, mgr.metadataFetchDelayMs(time.milliseconds()));
time.sleep(refreshBackoffMs);
assertEquals(0, mgr.metadataFetchDelayMs(time.milliseconds()));
}
@Test
public void testAuthenticationFailure() {
mgr.transitionToUpdatePending(time.milliseconds());
mgr.updateFailed(new AuthenticationException("Authentication failed"));
assertEquals(refreshBackoffMs, mgr.metadataFetchDelayMs(time.milliseconds()));
assertThrows(AuthenticationException.class, mgr::isReady);
mgr.update(mockCluster(), time.milliseconds());
assertTrue(mgr.isReady());
}
@Test
public void testAuthorizationFailure() {
mgr.transitionToUpdatePending(time.milliseconds());
mgr.updateFailed(new AuthorizationException("Authorization failed"));
assertEquals(refreshBackoffMs, mgr.metadataFetchDelayMs(time.milliseconds()));
assertThrows(AuthorizationException.class, mgr::isReady);
mgr.update(mockCluster(), time.milliseconds());
assertTrue(mgr.isReady());
}
@Test
public void testNeedsRebootstrap() {
long rebootstrapTriggerMs = 1000;
mgr.update(Cluster.bootstrap(Collections.singletonList(new InetSocketAddress("localhost", 9999))), time.milliseconds());
assertFalse(mgr.needsRebootstrap(time.milliseconds(), rebootstrapTriggerMs));
assertFalse(mgr.needsRebootstrap(time.milliseconds() + 2000, rebootstrapTriggerMs));
mgr.transitionToUpdatePending(time.milliseconds());
assertFalse(mgr.needsRebootstrap(time.milliseconds(), rebootstrapTriggerMs));
assertTrue(mgr.needsRebootstrap(time.milliseconds() + 1001, rebootstrapTriggerMs));
time.sleep(100);
mgr.updateFailed(new RuntimeException());
assertFalse(mgr.needsRebootstrap(time.milliseconds() + 900, rebootstrapTriggerMs));
assertTrue(mgr.needsRebootstrap(time.milliseconds() + 901, rebootstrapTriggerMs));
time.sleep(1000);
mgr.update(mockCluster(), time.milliseconds());
assertFalse(mgr.needsRebootstrap(time.milliseconds(), rebootstrapTriggerMs));
assertFalse(mgr.needsRebootstrap(time.milliseconds() + 2000, rebootstrapTriggerMs));
time.sleep(1000);
mgr.transitionToUpdatePending(time.milliseconds());
assertFalse(mgr.needsRebootstrap(time.milliseconds(), rebootstrapTriggerMs));
assertTrue(mgr.needsRebootstrap(time.milliseconds() + 1001, rebootstrapTriggerMs));
time.sleep(1001);
assertTrue(mgr.needsRebootstrap(time.milliseconds(), rebootstrapTriggerMs));
mgr.rebootstrap(time.milliseconds());
assertFalse(mgr.needsRebootstrap(time.milliseconds(), rebootstrapTriggerMs));
assertFalse(mgr.needsRebootstrap(time.milliseconds() + 1000, rebootstrapTriggerMs));
assertTrue(mgr.needsRebootstrap(time.milliseconds() + 1001, rebootstrapTriggerMs));
mgr.initiateRebootstrap();
assertTrue(mgr.needsRebootstrap(time.milliseconds(), rebootstrapTriggerMs));
mgr.rebootstrap(time.milliseconds());
assertFalse(mgr.needsRebootstrap(time.milliseconds(), rebootstrapTriggerMs));
assertFalse(mgr.needsRebootstrap(time.milliseconds() + 1000, rebootstrapTriggerMs));
assertTrue(mgr.needsRebootstrap(time.milliseconds() + 1001, rebootstrapTriggerMs));
}
private static Cluster mockCluster() {
HashMap<Integer, Node> nodes = new HashMap<>();
nodes.put(0, new Node(0, "localhost", 8121));
nodes.put(1, new Node(1, "localhost", 8122));
nodes.put(2, new Node(2, "localhost", 8123));
return new Cluster("mockClusterId", nodes.values(),
Collections.emptySet(), Collections.emptySet(),
Collections.emptySet(), nodes.get(0));
}
}
| AdminMetadataManagerTest |
java | hibernate__hibernate-orm | hibernate-core/src/main/java/org/hibernate/boot/model/source/spi/ColumnBindingDefaults.java | {
"start": 181,
"end": 1220
} | interface ____ {
/**
* How should non-specification of value insertion by the individual value sources here be
* interpreted in terms of defaulting that value.
*
* @return {@code true} Indicates that insertions are enabled by default for all value sources which
* do not explicitly specify.
*/
boolean areValuesIncludedInInsertByDefault();
/**
* How should non-specification of value updating by the individual value sources here be
* interpreted in terms of defaulting that value.
*
* @return {@code true} Indicates that updates are enabled by default for all value sources which
* do not explicitly specify.
*/
boolean areValuesIncludedInUpdateByDefault();
/**
* How should non-specification of value nullability by the individual value sources here be
* interpreted in terms of defaulting that value.
*
* @return {@code true} Indicates that insertions are enabled by default for all value sources which
* do not explicitly specify.
*/
boolean areValuesNullableByDefault();
}
| ColumnBindingDefaults |
java | junit-team__junit5 | platform-tests/src/test/java/org/junit/platform/suite/engine/SuiteLauncherDiscoveryRequestBuilderTests.java | {
"start": 4820,
"end": 5573
} | class ____ {
}
LauncherDiscoveryRequest request = builder.applyConfigurationParametersFromSuite(Suite.class).build();
ConfigurationParameters configuration = request.getConfigurationParameters();
Optional<String> parameterOne = configuration.get("com.example.prop.first");
assertEquals(Optional.of("first value from override file"), parameterOne);
Optional<String> parameterTwo = configuration.get("com.example.prop.second");
assertEquals(Optional.of("second value"), parameterTwo);
}
@Test
void configurationParametersResource_explicitParametersTakePrecedence() {
@ConfigurationParametersResource("config-test.properties")
@ConfigurationParameter(key = "com.example.prop.first", value = "first value from explicit parameter")
| Suite |
java | quarkusio__quarkus | extensions/resteasy-reactive/rest-client/deployment/src/test/java/io/quarkus/rest/client/reactive/form/FormParamTest.java | {
"start": 2918,
"end": 3169
} | interface ____ {
@PUT
@Consumes(MediaType.APPLICATION_FORM_URLENCODED)
@Produces(MediaType.TEXT_PLAIN)
String form(@FormParam("subParam1") String formParam1, @FormParam("subParam2") String formParam2);
}
}
| SubFormClient |
java | spring-projects__spring-framework | spring-test/src/main/java/org/springframework/test/web/servlet/client/DefaultRestTestClient.java | {
"start": 9170,
"end": 12134
} | class ____ implements ResponseSpec {
private final ExchangeResult exchangeResult;
private final Consumer<EntityExchangeResult<?>> entityResultConsumer;
DefaultResponseSpec(ExchangeResult result, Consumer<EntityExchangeResult<?>> entityResultConsumer) {
this.exchangeResult = result;
this.entityResultConsumer = entityResultConsumer;
}
@Override
public StatusAssertions expectStatus() {
return new StatusAssertions(this.exchangeResult, this);
}
@Override
public HeaderAssertions expectHeader() {
return new HeaderAssertions(this.exchangeResult, this);
}
@Override
public CookieAssertions expectCookie() {
return new CookieAssertions(this.exchangeResult, this);
}
@Override
public <B> BodySpec<B, ?> expectBody(Class<B> bodyType) {
B body = this.exchangeResult.getClientResponse().bodyTo(bodyType);
EntityExchangeResult<B> result = new EntityExchangeResult<>(this.exchangeResult, body);
return new DefaultBodySpec<>(result);
}
@Override
public <B> BodySpec<B, ?> expectBody(ParameterizedTypeReference<B> bodyType) {
B body = this.exchangeResult.getClientResponse().bodyTo(bodyType);
EntityExchangeResult<B> result = initExchangeResult(body);
return new DefaultBodySpec<>(result);
}
@Override
public BodyContentSpec expectBody() {
byte[] body = this.exchangeResult.getClientResponse().bodyTo(byte[].class);
EntityExchangeResult<byte[]> result = initExchangeResult(body);
return new DefaultBodyContentSpec(result);
}
@Override
public <T> EntityExchangeResult<T> returnResult(Class<T> elementClass) {
return initExchangeResult(this.exchangeResult.getClientResponse().bodyTo(elementClass));
}
@Override
public <T> EntityExchangeResult<T> returnResult(ParameterizedTypeReference<T> elementTypeRef) {
return initExchangeResult(this.exchangeResult.getClientResponse().bodyTo(elementTypeRef));
}
private <B> EntityExchangeResult<B> initExchangeResult(@Nullable B body) {
EntityExchangeResult<B> result = new EntityExchangeResult<>(this.exchangeResult, body);
result.assertWithDiagnostics(() -> this.entityResultConsumer.accept(result));
return result;
}
@Override
public ResponseSpec expectAll(ResponseSpecConsumer... consumers) {
ExceptionCollector exceptionCollector = new ExceptionCollector();
for (ResponseSpecConsumer consumer : consumers) {
exceptionCollector.execute(() -> consumer.accept(this));
}
try {
exceptionCollector.assertEmpty();
}
catch (RuntimeException ex) {
throw ex;
}
catch (Exception ex) {
// In theory, a ResponseSpecConsumer should never throw an Exception
// that is not a RuntimeException, but since ExceptionCollector may
// throw a checked Exception, we handle this to appease the compiler
// and in case someone uses a "sneaky throws" technique.
throw new AssertionError(ex.getMessage(), ex);
}
return this;
}
}
private static | DefaultResponseSpec |
java | google__guava | android/guava/src/com/google/common/collect/Iterators.java | {
"start": 2768,
"end": 3473
} | class ____ {
private Iterators() {}
/**
* Returns the empty iterator.
*
* <p>The {@link Iterable} equivalent of this method is {@link ImmutableSet#of()}.
*/
static <T extends @Nullable Object> UnmodifiableIterator<T> emptyIterator() {
return emptyListIterator();
}
/**
* Returns the empty iterator.
*
* <p>The {@link Iterable} equivalent of this method is {@link ImmutableSet#of()}.
*/
// Casting to any type is safe since there are no actual elements.
@SuppressWarnings("unchecked")
static <T extends @Nullable Object> UnmodifiableListIterator<T> emptyListIterator() {
return (UnmodifiableListIterator<T>) ArrayItr.EMPTY;
}
/**
* This is an | Iterators |
java | elastic__elasticsearch | server/src/main/java/org/elasticsearch/search/aggregations/pipeline/AvgBucketPipelineAggregationBuilder.java | {
"start": 790,
"end": 2398
} | class ____ extends BucketMetricsPipelineAggregationBuilder<AvgBucketPipelineAggregationBuilder> {
public static final String NAME = "avg_bucket";
public AvgBucketPipelineAggregationBuilder(String name, String bucketsPath) {
super(name, NAME, new String[] { bucketsPath });
}
/**
* Read from a stream.
*/
public AvgBucketPipelineAggregationBuilder(StreamInput in) throws IOException {
super(in, NAME);
}
@Override
protected void innerWriteTo(StreamOutput out) throws IOException {
// Do nothing, no extra state to write to stream
}
@Override
protected PipelineAggregator createInternal(Map<String, Object> metadata) {
return new AvgBucketPipelineAggregator(name, bucketsPaths, gapPolicy(), formatter(), metadata);
}
@Override
protected XContentBuilder doXContentBody(XContentBuilder builder, Params params) throws IOException {
return builder;
}
public static final PipelineAggregator.Parser PARSER = new BucketMetricsParser() {
@Override
protected AvgBucketPipelineAggregationBuilder buildFactory(
String pipelineAggregatorName,
String bucketsPath,
Map<String, Object> params
) {
return new AvgBucketPipelineAggregationBuilder(pipelineAggregatorName, bucketsPath);
}
};
@Override
public String getWriteableName() {
return NAME;
}
@Override
public TransportVersion getMinimalSupportedVersion() {
return TransportVersion.zero();
}
}
| AvgBucketPipelineAggregationBuilder |
java | apache__camel | components/camel-openapi-java/src/main/java/org/apache/camel/openapi/RestOpenApiReader.java | {
"start": 48534,
"end": 48691
} | class ____ annotated with openApi annotations its parsed into a OpenApi model representation which is added
* to openApi
*
* @param clazz the | is |
java | micronaut-projects__micronaut-core | http-client/src/main/java/io/micronaut/http/client/netty/PoolSink.java | {
"start": 956,
"end": 1047
} | interface ____<T> extends Sinks.One<T> {
@Nullable
BlockHint getBlockHint();
}
| PoolSink |
java | apache__hadoop | hadoop-common-project/hadoop-auth/src/main/java/org/apache/hadoop/security/authentication/server/AltKerberosAuthenticationHandler.java | {
"start": 1463,
"end": 5652
} | class ____
extends KerberosAuthenticationHandler {
/**
* Constant that identifies the authentication mechanism.
*/
public static final String TYPE = "alt-kerberos";
/**
* Constant for the configuration property that indicates which user agents
* are not considered browsers (comma separated)
*/
public static final String NON_BROWSER_USER_AGENTS =
TYPE + ".non-browser.user-agents";
private static final String NON_BROWSER_USER_AGENTS_DEFAULT =
"java,curl,wget,perl";
private String[] nonBrowserUserAgents;
/**
* Returns the authentication type of the authentication handler,
* 'alt-kerberos'.
*
* @return the authentication type of the authentication handler,
* 'alt-kerberos'.
*/
@Override
public String getType() {
return TYPE;
}
@Override
public void init(Properties config) throws ServletException {
super.init(config);
nonBrowserUserAgents = config.getProperty(
NON_BROWSER_USER_AGENTS, NON_BROWSER_USER_AGENTS_DEFAULT)
.split("\\W*,\\W*");
for (int i = 0; i < nonBrowserUserAgents.length; i++) {
nonBrowserUserAgents[i] =
nonBrowserUserAgents[i].toLowerCase(Locale.ENGLISH);
}
}
/**
* It enforces the the Kerberos SPNEGO authentication sequence returning an
* {@link AuthenticationToken} only after the Kerberos SPNEGO sequence has
* completed successfully (in the case of Java access) and only after the
* custom authentication implemented by the subclass in alternateAuthenticate
* has completed successfully (in the case of browser access).
*
* @param request the HTTP client request.
* @param response the HTTP client response.
*
* @return an authentication token if the request is authorized or null
*
* @throws IOException thrown if an IO error occurred
* @throws AuthenticationException thrown if an authentication error occurred
*/
@Override
public AuthenticationToken authenticate(HttpServletRequest request,
HttpServletResponse response)
throws IOException, AuthenticationException {
AuthenticationToken token;
if (isBrowser(request.getHeader("User-Agent"))) {
token = alternateAuthenticate(request, response);
}
else {
token = super.authenticate(request, response);
}
return token;
}
/**
* This method parses the User-Agent String and returns whether or not it
* refers to a browser. If its not a browser, then Kerberos authentication
* will be used; if it is a browser, alternateAuthenticate from the subclass
* will be used.
* <p>
* A User-Agent String is considered to be a browser if it does not contain
* any of the values from alt-kerberos.non-browser.user-agents; the default
* behavior is to consider everything a browser unless it contains one of:
* "java", "curl", "wget", or "perl". Subclasses can optionally override
* this method to use different behavior.
*
* @param userAgent The User-Agent String, or null if there isn't one
* @return true if the User-Agent String refers to a browser, false if not
*/
protected boolean isBrowser(String userAgent) {
if (userAgent == null) {
return false;
}
userAgent = userAgent.toLowerCase(Locale.ENGLISH);
boolean isBrowser = true;
for (String nonBrowserUserAgent : nonBrowserUserAgents) {
if (userAgent.contains(nonBrowserUserAgent)) {
isBrowser = false;
break;
}
}
return isBrowser;
}
/**
* Subclasses should implement this method to provide the custom
* authentication to be used for browsers.
*
* @param request the HTTP client request.
* @param response the HTTP client response.
* @return an authentication token if the request is authorized, or null
* @throws IOException thrown if an IO error occurs
* @throws AuthenticationException thrown if an authentication error occurs
*/
public abstract AuthenticationToken alternateAuthenticate(
HttpServletRequest request, HttpServletResponse response)
throws IOException, AuthenticationException;
}
| AltKerberosAuthenticationHandler |
java | apache__hadoop | hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-timelineservice/src/main/java/org/apache/hadoop/yarn/server/timelineservice/reader/TimelineParserForKVFilters.java | {
"start": 1462,
"end": 2864
} | class ____ extends TimelineParserForCompareExpr {
// Indicates if value has to be interpreted as a string.
private final boolean valueAsString;
public TimelineParserForKVFilters(String expression, boolean valAsStr) {
super(expression, "Config/Info Filter");
this.valueAsString = valAsStr;
}
protected TimelineFilter createFilter() {
return new TimelineKeyValueFilter();
}
protected Object parseValue(String strValue) {
if (!valueAsString) {
try {
return GenericObjectMapper.OBJECT_READER.readValue(strValue);
} catch (IOException e) {
return strValue;
}
} else {
return strValue;
}
}
@Override
protected void setCompareOpToCurrentFilter(TimelineCompareOp compareOp,
boolean keyMustExistFlag) throws TimelineParseException {
if (compareOp != TimelineCompareOp.EQUAL &&
compareOp != TimelineCompareOp.NOT_EQUAL) {
throw new TimelineParseException("TimelineCompareOp for kv-filter " +
"should be EQUAL or NOT_EQUAL");
}
((TimelineKeyValueFilter)getCurrentFilter()).setCompareOp(
compareOp, keyMustExistFlag);
}
@Override
protected void setValueToCurrentFilter(Object value) {
TimelineFilter currentFilter = getCurrentFilter();
if (currentFilter != null) {
((TimelineKeyValueFilter)currentFilter).setValue(value);
}
}
}
| TimelineParserForKVFilters |
java | apache__avro | lang/java/ipc/src/main/java/org/apache/avro/ipc/stats/IntegerHistogram.java | {
"start": 978,
"end": 1685
} | class ____<B> extends Histogram<B, Integer> {
private float runningSum;
private float runningSumOfSquares;
public IntegerHistogram(Segmenter<B, Integer> segmenter) {
super(segmenter);
}
@Override
public void add(Integer value) {
super.add(value);
runningSum += value;
runningSumOfSquares += value * value;
}
public float getMean() {
if (totalCount == 0) {
return -1;
}
return runningSum / (float) totalCount;
}
public float getUnbiasedStdDev() {
if (totalCount <= 1) {
return -1;
}
float mean = getMean();
return (float) Math.sqrt((runningSumOfSquares - totalCount * mean * mean) / (float) (totalCount - 1));
}
}
| IntegerHistogram |
java | FasterXML__jackson-core | src/test/java/tools/jackson/core/unittest/write/FastDoubleObjectWriteTest.java | {
"start": 142,
"end": 410
} | class ____ extends ObjectWriteTest {
private final JsonFactory FACTORY = JsonFactory.builder().enable(StreamWriteFeature.USE_FAST_DOUBLE_WRITER).build();
@Override
protected JsonFactory jsonFactory() {
return FACTORY;
}
}
| FastDoubleObjectWriteTest |
java | spring-projects__spring-framework | spring-aop/src/main/java/org/springframework/aop/target/LazyInitTargetSource.java | {
"start": 2412,
"end": 3055
} | class ____ extends AbstractBeanFactoryBasedTargetSource {
private @Nullable Object target;
@Override
public synchronized Object getTarget() throws BeansException {
if (this.target == null) {
this.target = getBeanFactory().getBean(getTargetBeanName());
postProcessTargetObject(this.target);
}
return this.target;
}
/**
* Subclasses may override this method to perform additional processing on
* the target object when it is first loaded.
* @param targetObject the target object that has just been instantiated (and configured)
*/
protected void postProcessTargetObject(Object targetObject) {
}
}
| LazyInitTargetSource |
java | spring-projects__spring-framework | spring-context/src/test/java/org/springframework/scheduling/support/PeriodicTriggerTests.java | {
"start": 8517,
"end": 8540
} | class
____ static | private |
java | quarkusio__quarkus | extensions/smallrye-health/deployment/src/test/java/io/quarkus/smallrye/health/test/BlockingNonBlockingTest.java | {
"start": 2357,
"end": 2651
} | class ____ {
@Inject
SmallRyeHealthReporter smallRyeHealthReporter;
@Route(path = "/start-health", methods = Route.HttpMethod.GET)
@Blocking
public String health() {
return smallRyeHealthReporter.getHealth().toString();
}
}
}
| Routes |
java | hibernate__hibernate-orm | hibernate-core/src/main/java/org/hibernate/resource/beans/container/internal/CdiBeanContainerExtendedAccessImpl.java | {
"start": 2713,
"end": 3843
} | class ____<B> implements ContainedBeanImplementor<B> {
private final Class<B> beanType;
private final BeanLifecycleStrategy lifecycleStrategy;
private final BeanInstanceProducer fallbackProducer;
private ContainedBeanImplementor<B> delegateContainedBean;
private BeanImpl(
Class<B> beanType,
BeanLifecycleStrategy lifecycleStrategy,
BeanInstanceProducer fallbackProducer) {
this.beanType = beanType;
this.lifecycleStrategy = lifecycleStrategy;
this.fallbackProducer = fallbackProducer;
}
@Override
public Class<B> getBeanClass() {
return beanType;
}
@Override
public void initialize() {
if ( delegateContainedBean == null ) {
delegateContainedBean = lifecycleStrategy.createBean( beanType, fallbackProducer, DUMMY_BEAN_CONTAINER );
}
delegateContainedBean.initialize();
}
@Override
public B getBeanInstance() {
if ( delegateContainedBean == null ) {
initialize();
}
return delegateContainedBean.getBeanInstance();
}
@Override
public void release() {
delegateContainedBean.release();
delegateContainedBean = null;
}
}
private | BeanImpl |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.