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 | apache__kafka | connect/runtime/src/main/java/org/apache/kafka/connect/tools/TransformationDoc.java | {
"start": 1816,
"end": 4426
} | class ____ {
private record DocInfo(String transformationName, String overview, ConfigDef configDef) {
}
private static final List<DocInfo> TRANSFORMATIONS = List.of(
new DocInfo(Cast.class.getName(), Cast.OVERVIEW_DOC, Cast.CONFIG_DEF),
new DocInfo(DropHeaders.class.getName(), DropHeaders.OVERVIEW_DOC, DropHeaders.CONFIG_DEF),
new DocInfo(ExtractField.class.getName(), ExtractField.OVERVIEW_DOC, ExtractField.CONFIG_DEF),
new DocInfo(Filter.class.getName(), Filter.OVERVIEW_DOC, Filter.CONFIG_DEF),
new DocInfo(Flatten.class.getName(), Flatten.OVERVIEW_DOC, Flatten.CONFIG_DEF),
new DocInfo(HeaderFrom.class.getName(), HeaderFrom.OVERVIEW_DOC, HeaderFrom.CONFIG_DEF),
new DocInfo(HoistField.class.getName(), HoistField.OVERVIEW_DOC, HoistField.CONFIG_DEF),
new DocInfo(InsertField.class.getName(), InsertField.OVERVIEW_DOC, InsertField.CONFIG_DEF),
new DocInfo(InsertHeader.class.getName(), InsertHeader.OVERVIEW_DOC, InsertHeader.CONFIG_DEF),
new DocInfo(MaskField.class.getName(), MaskField.OVERVIEW_DOC, MaskField.CONFIG_DEF),
new DocInfo(RegexRouter.class.getName(), RegexRouter.OVERVIEW_DOC, RegexRouter.CONFIG_DEF),
new DocInfo(ReplaceField.class.getName(), ReplaceField.OVERVIEW_DOC, ReplaceField.CONFIG_DEF),
new DocInfo(SetSchemaMetadata.class.getName(), SetSchemaMetadata.OVERVIEW_DOC, SetSchemaMetadata.CONFIG_DEF),
new DocInfo(TimestampConverter.class.getName(), TimestampConverter.OVERVIEW_DOC, TimestampConverter.CONFIG_DEF),
new DocInfo(TimestampRouter.class.getName(), TimestampRouter.OVERVIEW_DOC, TimestampRouter.CONFIG_DEF),
new DocInfo(ValueToKey.class.getName(), ValueToKey.OVERVIEW_DOC, ValueToKey.CONFIG_DEF)
);
private static String toHtml() {
StringBuilder b = new StringBuilder();
for (final DocInfo docInfo : TRANSFORMATIONS) {
b.append("<div id=\"" + docInfo.transformationName + "\">\n");
b.append("<h5>");
b.append("<a href=\"#" + docInfo.transformationName + "\">" + docInfo.transformationName + "</a>");
b.append("</h5>\n");
b.append(docInfo.overview + "\n");
b.append("<p/>\n");
b.append(docInfo.configDef.toHtml(6, key -> docInfo.transformationName + "_" + key) + "\n");
b.append("</div>\n");
}
return b.toString();
}
public static void main(String... args) {
System.out.println(toHtml());
}
}
| TransformationDoc |
java | apache__kafka | storage/src/test/java/org/apache/kafka/server/log/remote/storage/RemoteLogReaderTest.java | {
"start": 2060,
"end": 7197
} | class ____ {
public static final String TOPIC = "test";
RemoteLogManager mockRLM = mock(RemoteLogManager.class);
BrokerTopicStats brokerTopicStats = null;
RLMQuotaManager mockQuotaManager = mock(RLMQuotaManager.class);
LogOffsetMetadata logOffsetMetadata = new LogOffsetMetadata(100);
Records records = mock(Records.class);
Timer timer = mock(Timer.class);
@BeforeEach
public void setUp() throws Exception {
TestUtils.clearYammerMetrics();
brokerTopicStats = new BrokerTopicStats(true);
when(timer.time(any(Callable.class))).thenAnswer(ans -> ans.getArgument(0, Callable.class).call());
}
@Test
public void testRemoteLogReaderWithoutError() throws RemoteStorageException, IOException {
FetchDataInfo fetchDataInfo = new FetchDataInfo(logOffsetMetadata, records);
when(records.sizeInBytes()).thenReturn(100);
when(mockRLM.read(any(RemoteStorageFetchInfo.class))).thenReturn(fetchDataInfo);
Consumer<RemoteLogReadResult> callback = mock(Consumer.class);
RemoteStorageFetchInfo remoteStorageFetchInfo = new RemoteStorageFetchInfo(0, false, new TopicIdPartition(Uuid.randomUuid(), 0, TOPIC), null, null);
RemoteLogReader remoteLogReader =
new RemoteLogReader(remoteStorageFetchInfo, mockRLM, callback, brokerTopicStats, mockQuotaManager, timer);
remoteLogReader.call();
// verify the callback did get invoked with the expected remoteLogReadResult
ArgumentCaptor<RemoteLogReadResult> remoteLogReadResultArg = ArgumentCaptor.forClass(RemoteLogReadResult.class);
verify(callback, times(1)).accept(remoteLogReadResultArg.capture());
RemoteLogReadResult actualRemoteLogReadResult = remoteLogReadResultArg.getValue();
assertFalse(actualRemoteLogReadResult.error().isPresent());
assertTrue(actualRemoteLogReadResult.fetchDataInfo().isPresent());
assertEquals(fetchDataInfo, actualRemoteLogReadResult.fetchDataInfo().get());
// verify the record method on quota manager was called with the expected value
ArgumentCaptor<Double> recordedArg = ArgumentCaptor.forClass(Double.class);
verify(mockQuotaManager, times(1)).record(recordedArg.capture());
assertEquals(100, recordedArg.getValue());
// Verify metrics for remote reads are updated correctly
assertEquals(1, brokerTopicStats.topicStats(TOPIC).remoteFetchRequestRate().count());
assertEquals(100, brokerTopicStats.topicStats(TOPIC).remoteFetchBytesRate().count());
assertEquals(0, brokerTopicStats.topicStats(TOPIC).failedRemoteFetchRequestRate().count());
// Verify aggregate metrics
assertEquals(1, brokerTopicStats.allTopicsStats().remoteFetchRequestRate().count());
assertEquals(100, brokerTopicStats.allTopicsStats().remoteFetchBytesRate().count());
assertEquals(0, brokerTopicStats.allTopicsStats().failedRemoteFetchRequestRate().count());
}
@Test
public void testRemoteLogReaderWithError() throws RemoteStorageException, IOException {
when(mockRLM.read(any(RemoteStorageFetchInfo.class))).thenThrow(new RuntimeException("error"));
Consumer<RemoteLogReadResult> callback = mock(Consumer.class);
RemoteStorageFetchInfo remoteStorageFetchInfo = new RemoteStorageFetchInfo(0, false, new TopicIdPartition(Uuid.randomUuid(), 0, TOPIC), null, null);
RemoteLogReader remoteLogReader =
new RemoteLogReader(remoteStorageFetchInfo, mockRLM, callback, brokerTopicStats, mockQuotaManager, timer);
remoteLogReader.call();
// verify the callback did get invoked with the expected remoteLogReadResult
ArgumentCaptor<RemoteLogReadResult> remoteLogReadResultArg = ArgumentCaptor.forClass(RemoteLogReadResult.class);
verify(callback, times(1)).accept(remoteLogReadResultArg.capture());
RemoteLogReadResult actualRemoteLogReadResult = remoteLogReadResultArg.getValue();
assertTrue(actualRemoteLogReadResult.error().isPresent());
assertFalse(actualRemoteLogReadResult.fetchDataInfo().isPresent());
// verify the record method on quota manager was called with the expected value
ArgumentCaptor<Double> recordedArg = ArgumentCaptor.forClass(Double.class);
verify(mockQuotaManager, times(1)).record(recordedArg.capture());
assertEquals(0, recordedArg.getValue());
// Verify metrics for remote reads are updated correctly
assertEquals(1, brokerTopicStats.topicStats(TOPIC).remoteFetchRequestRate().count());
assertEquals(0, brokerTopicStats.topicStats(TOPIC).remoteFetchBytesRate().count());
assertEquals(1, brokerTopicStats.topicStats(TOPIC).failedRemoteFetchRequestRate().count());
// Verify aggregate metrics
assertEquals(1, brokerTopicStats.allTopicsStats().remoteFetchRequestRate().count());
assertEquals(0, brokerTopicStats.allTopicsStats().remoteFetchBytesRate().count());
assertEquals(1, brokerTopicStats.allTopicsStats().failedRemoteFetchRequestRate().count());
}
}
| RemoteLogReaderTest |
java | quarkusio__quarkus | extensions/resteasy-reactive/rest-jackson/deployment/src/test/java/io/quarkus/resteasy/reactive/jackson/deployment/test/CustomSerializationResource.java | {
"start": 2686,
"end": 3488
} | class ____ implements BiFunction<ObjectMapper, Type, ObjectWriter> {
public static final AtomicInteger count = new AtomicInteger();
public UnquotedFieldsPersonSerialization() {
count.incrementAndGet();
}
@Override
public ObjectWriter apply(ObjectMapper objectMapper, Type type) {
if (type instanceof ParameterizedType) {
type = ((ParameterizedType) type).getActualTypeArguments()[0];
}
if (!type.getTypeName().equals(Person.class.getName())) {
throw new IllegalArgumentException("Only Person type can be handled");
}
return objectMapper.writer().without(JsonWriteFeature.QUOTE_FIELD_NAMES);
}
}
public static | UnquotedFieldsPersonSerialization |
java | apache__flink | flink-formats/flink-protobuf/src/test/java/org/apache/flink/formats/protobuf/MultiLevelMessageProtoToRowTest.java | {
"start": 1188,
"end": 2452
} | class ____ {
@Test
public void testMessage() throws Exception {
MultipleLevelMessageTest.InnerMessageTest1.InnerMessageTest2 innerMessageTest2 =
MultipleLevelMessageTest.InnerMessageTest1.InnerMessageTest2.newBuilder()
.setA(1)
.setB(2L)
.build();
MultipleLevelMessageTest.InnerMessageTest1 innerMessageTest =
MultipleLevelMessageTest.InnerMessageTest1.newBuilder()
.setC(false)
.setA(innerMessageTest2)
.build();
MultipleLevelMessageTest multipleLevelMessageTest =
MultipleLevelMessageTest.newBuilder().setD(innerMessageTest).setA(1).build();
RowData row =
ProtobufTestHelper.pbBytesToRow(
MultipleLevelMessageTest.class, multipleLevelMessageTest.toByteArray());
assertEquals(4, row.getArity());
RowData subRow = (RowData) row.getRow(3, 2);
assertFalse(subRow.getBoolean(1));
RowData subSubRow = (RowData) subRow.getRow(0, 2);
assertEquals(1, subSubRow.getInt(0));
assertEquals(2L, subSubRow.getLong(1));
}
}
| MultiLevelMessageProtoToRowTest |
java | apache__flink | flink-streaming-java/src/test/java/org/apache/flink/streaming/api/graph/StreamingJobGraphGeneratorWithOperatorAttributesTest.java | {
"start": 19171,
"end": 19728
} | class ____<IN1, IN2, OUT>
extends CoProcessOperator<IN1, IN2, OUT> {
private final OperatorAttributes attributes;
public TwoInputStreamOperatorWithConfigurableOperatorAttributes(
OperatorAttributes attributes) {
super(new NoOpCoProcessFunction<>());
this.attributes = attributes;
}
@Override
public OperatorAttributes getOperatorAttributes() {
return attributes;
}
}
private static | TwoInputStreamOperatorWithConfigurableOperatorAttributes |
java | assertj__assertj-core | assertj-tests/assertj-integration-tests/assertj-core-tests/src/test/java/org/assertj/tests/core/api/recursive/data/FriendlyPerson.java | {
"start": 776,
"end": 1334
} | class ____ extends Person {
public List<FriendlyPerson> friends = new ArrayList<>();
public Set<FriendlyPerson> otherFriends = new HashSet<>();
public FriendlyPerson[] arrayFriends = new FriendlyPerson[0];
public FriendlyPerson() {
super();
}
public FriendlyPerson(String name) {
super(name);
}
public static FriendlyPerson friend(String name) {
return new FriendlyPerson(name);
}
public void add(FriendlyPerson friend) {
friends.add(friend);
arrayFriends = friends.toArray(new FriendlyPerson[0]);
}
}
| FriendlyPerson |
java | hibernate__hibernate-orm | hibernate-core/src/test/java/org/hibernate/orm/test/function/json/JsonQueryTest.java | {
"start": 1414,
"end": 4616
} | class ____ {
@BeforeEach
public void prepareData(SessionFactoryScope scope) {
scope.inTransaction( em -> {
EntityWithJson entity = new EntityWithJson();
entity.setId( 1L );
entity.getJson().put( "theInt", 1 );
entity.getJson().put( "theFloat", 0.1 );
entity.getJson().put( "theString", "abc" );
entity.getJson().put( "theBoolean", true );
entity.getJson().put( "theNull", null );
entity.getJson().put( "theArray", new String[] { "a", "b", "c" } );
entity.getJson().put( "theObject", new HashMap<>( entity.getJson() ) );
em.persist(entity);
} );
}
@AfterEach
public void cleanup(SessionFactoryScope scope) {
scope.getSessionFactory().getSchemaManager().truncate();
}
@Test
public void testSimple(SessionFactoryScope scope) {
scope.inSession( em -> {
//tag::hql-json-query-example[]
List<Tuple> results = em.createQuery( "select json_query(e.json, '$.theString') from EntityWithJson e", Tuple.class )
.getResultList();
//end::hql-json-query-example[]
assertEquals( 1, results.size() );
} );
}
@Test
public void testPassing(SessionFactoryScope scope) {
scope.inSession( em -> {
//tag::hql-json-query-passing-example[]
List<Tuple> results = em.createQuery( "select json_query(e.json, '$.theArray[$idx]' passing 1 as idx) from EntityWithJson e", Tuple.class )
.getResultList();
//end::hql-json-query-passing-example[]
assertEquals( 1, results.size() );
} );
}
@Test
public void testWithWrapper(SessionFactoryScope scope) {
scope.inSession( em -> {
//tag::hql-json-query-with-wrapper-example[]
List<Tuple> results = em.createQuery( "select json_query(e.json, '$.theInt' with wrapper) from EntityWithJson e", Tuple.class )
.getResultList();
//end::hql-json-query-with-wrapper-example[]
assertEquals( 1, results.size() );
} );
}
@Test
@SkipForDialect(dialectClass = MariaDBDialect.class, reason = "MariaDB reports the error 4038 as warning and simply returns null")
public void testOnError(SessionFactoryScope scope) {
scope.inSession( em -> {
try {
//tag::hql-json-query-on-error-example[]
em.createQuery( "select json_query('invalidJson', '$.theInt' error on error) from EntityWithJson e")
.getResultList();
//end::hql-json-query-on-error-example[]
fail("error clause should fail because of invalid json document");
}
catch ( HibernateException e ) {
if ( !( e instanceof JDBCException ) && !( e instanceof ExecutionException ) ) {
throw e;
}
}
} );
}
@Test
@RequiresDialectFeature( feature = DialectFeatureChecks.SupportsJsonValueErrorBehavior.class)
public void testOnEmpty(SessionFactoryScope scope) {
scope.inSession( em -> {
try {
//tag::hql-json-query-on-empty-example[]
em.createQuery("select json_query(e.json, '$.nonExisting' error on empty error on error) from EntityWithJson e" )
.getResultList();
//end::hql-json-query-on-empty-example[]
fail("empty clause should fail because of json path doesn't produce results");
}
catch ( HibernateException e ) {
if ( !( e instanceof JDBCException ) && !( e instanceof ExecutionException ) ) {
throw e;
}
}
} );
}
}
| JsonQueryTest |
java | google__error-prone | core/src/test/java/com/google/errorprone/bugpatterns/inlineme/ValidatorTest.java | {
"start": 5111,
"end": 5783
} | class ____ {
@InlineMe(replacement = "this.after(/* name1= */ name1, /* name2= */ name2)")
@Deprecated
public void before(String name1, String name2) {
after(/* name1= */ name1, /* name2= */ name2);
}
public void after(String name1, String name2) {}
}
""")
.doTest();
}
@Test
public void instanceMethod_withTrailingComment() {
helper
.addSourceLines(
"Client.java",
"""
import com.google.errorprone.annotations.InlineMe;
import java.util.function.Supplier;
public final | Client |
java | spring-projects__spring-framework | spring-context/src/main/java/org/springframework/context/aot/CglibClassHandler.java | {
"start": 1585,
"end": 2550
} | class ____ {
private static final Consumer<Builder> instantiateCglibProxy = hint ->
hint.withMembers(MemberCategory.INVOKE_DECLARED_CONSTRUCTORS);
private final RuntimeHints runtimeHints;
private final GeneratedFiles generatedFiles;
CglibClassHandler(GenerationContext generationContext) {
this.runtimeHints = generationContext.getRuntimeHints();
this.generatedFiles = generationContext.getGeneratedFiles();
}
/**
* Handle the specified generated CGLIB class.
* @param cglibClassName the name of the generated class
* @param content the bytecode of the generated class
*/
public void handleGeneratedClass(String cglibClassName, byte[] content) {
registerHints(TypeReference.of(cglibClassName));
String path = cglibClassName.replace(".", "/") + ".class";
this.generatedFiles.addFile(Kind.CLASS, path, new ByteArrayResource(content));
}
/**
* Handle the specified loaded CGLIB class.
* @param cglibClass a cglib | CglibClassHandler |
java | apache__avro | lang/java/integration-test/codegen-test/src/test/java/org/apache/avro/codegentest/TestNestedRecordsWithDifferentNamespaces.java | {
"start": 1025,
"end": 1428
} | class ____ extends AbstractSpecificRecordTest {
@Test
void nestedRecordsWithDifferentNamespaces() {
NestedSomeNamespaceRecord instanceOfGeneratedClass = NestedSomeNamespaceRecord.newBuilder()
.setNestedRecordBuilder(NestedOtherNamespaceRecord.newBuilder().setSomeField(1)).build();
verifySerDeAndStandardMethods(instanceOfGeneratedClass);
}
}
| TestNestedRecordsWithDifferentNamespaces |
java | apache__flink | flink-clients/src/main/java/org/apache/flink/client/program/artifact/LocalArtifactFetcher.java | {
"start": 1129,
"end": 1606
} | class ____ extends ArtifactFetcher {
private static final Logger LOG = LoggerFactory.getLogger(FsArtifactFetcher.class);
@Override
File fetch(String uri, Configuration flinkConf, File targetDir) throws Exception {
URI resolvedUri = PackagedProgramUtils.resolveURI(uri);
File targetFile = new File(resolvedUri.getPath());
LOG.debug("Retrieved local file from {} as {}", uri, targetFile);
return targetFile;
}
}
| LocalArtifactFetcher |
java | hibernate__hibernate-orm | hibernate-core/src/test/java/org/hibernate/orm/test/inheritance/embeddable/InheritedPropertyTest.java | {
"start": 1114,
"end": 2654
} | class ____ {
@BeforeEach
void setUp(SessionFactoryScope scope) {
scope.inTransaction( session -> {
final var cat = new Cat();
cat.age = 7;
cat.name = "Jones";
cat.mother = "Kitty";
final var owner = new Owner();
owner.id = 1L;
owner.pet = cat;
session.persist( owner );
} );
}
@AfterEach
void tearDown(SessionFactoryScope scope) {
scope.getSessionFactory().getSchemaManager().truncate();
}
@Test
void testInheritedProperty(SessionFactoryScope scope) {
assertDoesNotThrow( () -> scope.inSession(
session -> session.createQuery(
"select o from Owner o where treat(o.pet as InheritedPropertyTest$Cat).mother = :mother",
Owner.class ) ) );
scope.inSession(
session -> {
final var cats = session.createQuery(
"select o from Owner o where treat(o.pet as InheritedPropertyTest$Cat).mother = :mother",
Owner.class )
.setParameter( "mother", "Kitty" )
.getResultList();
assertEquals( 1, cats.size() );
final var owner = cats.get( 0 );
assertInstanceOf( Cat.class, owner.pet );
assertEquals( "Jones", owner.pet.name );
assertEquals( "Kitty", ((Cat) owner.pet).mother );
} );
}
@Test
void testDeclaredPropertyCreateQuery(SessionFactoryScope scope) {
assertDoesNotThrow( () -> scope.inSession(
session -> session.createQuery(
"select o from Owner o where treat(o.pet as InheritedPropertyTest$Mammal).mother = :mother",
Owner.class ) ) );
}
@Entity(name = "Owner")
public static | InheritedPropertyTest |
java | hibernate__hibernate-orm | hibernate-core/src/test/java/org/hibernate/orm/test/bytecode/enhance/internal/bytebuddy/DirtyCheckingWithEmbeddableAndNonVisibleGenericMappedSuperclassTest.java | {
"start": 6531,
"end": 6840
} | class ____ {
@Column
private String text;
public MyEmbeddable() {
}
private MyEmbeddable(String text) {
this.text = text;
}
public String getText() {
return text;
}
public void setText(String text) {
this.text = text;
}
}
@Entity(name = "myentity")
public static | MyEmbeddable |
java | alibaba__nacos | config/src/main/java/com/alibaba/nacos/config/server/service/query/handler/FormalHandler.java | {
"start": 1314,
"end": 2843
} | class ____ extends AbstractConfigQueryHandler {
private static final String FORMAL_HANDLER = "formalHandler";
@Override
public String getName() {
return FORMAL_HANDLER;
}
@Override
public ConfigQueryChainResponse handle(ConfigQueryChainRequest request) throws IOException {
ConfigQueryChainResponse response = new ConfigQueryChainResponse();
String dataId = request.getDataId();
String group = request.getGroup();
String tenant = request.getTenant();
CacheItem cacheItem = ConfigChainEntryHandler.getThreadLocalCacheItem();
String md5 = cacheItem.getConfigCache().getMd5();
String content = ConfigDiskServiceFactory.getInstance().getContent(dataId, group, tenant);
if (StringUtils.isBlank(content)) {
response.setStatus(ConfigQueryChainResponse.ConfigQueryStatus.CONFIG_NOT_FOUND);
return response;
}
long lastModified = cacheItem.getConfigCache().getLastModifiedTs();
String encryptedDataKey = cacheItem.getConfigCache().getEncryptedDataKey();
String configType = cacheItem.getType();
response.setContent(content);
response.setMd5(md5);
response.setLastModified(lastModified);
response.setEncryptedDataKey(encryptedDataKey);
response.setConfigType(configType);
response.setStatus(ConfigQueryChainResponse.ConfigQueryStatus.CONFIG_FOUND_FORMAL);
return response;
}
} | FormalHandler |
java | spring-projects__spring-framework | spring-core/src/main/java/org/springframework/util/ReflectionUtils.java | {
"start": 31510,
"end": 31595
} | interface ____ on each field in the hierarchy.
*/
@FunctionalInterface
public | invoked |
java | hibernate__hibernate-orm | hibernate-core/src/main/java/org/hibernate/annotations/CollectionType.java | {
"start": 661,
"end": 1160
} | interface ____ {
/**
* Specifies the UserCollectionType to use when mapping the attribute
* to which this annotation is attached.
*/
Class<? extends UserCollectionType> type();
/**
* Specifies configuration information for the type. Note that if the named type is a
* {@link org.hibernate.usertype.UserCollectionType}, it must also implement
* {@link org.hibernate.usertype.ParameterizedType} in order to receive these values.
*/
Parameter[] parameters() default {};
}
| CollectionType |
java | spring-projects__spring-framework | spring-beans/src/main/java/org/springframework/beans/factory/annotation/AnnotatedGenericBeanDefinition.java | {
"start": 1839,
"end": 2874
} | class ____ extends GenericBeanDefinition implements AnnotatedBeanDefinition {
private final AnnotationMetadata metadata;
private @Nullable MethodMetadata factoryMethodMetadata;
/**
* Create a new AnnotatedGenericBeanDefinition for the given bean class.
* @param beanClass the loaded bean class
*/
public AnnotatedGenericBeanDefinition(Class<?> beanClass) {
setBeanClass(beanClass);
this.metadata = AnnotationMetadata.introspect(beanClass);
}
/**
* Create a new AnnotatedGenericBeanDefinition for the given annotation metadata,
* allowing for ASM-based processing and avoidance of early loading of the bean class.
* Note that this constructor is functionally equivalent to
* {@link org.springframework.context.annotation.ScannedGenericBeanDefinition
* ScannedGenericBeanDefinition}, however the semantics of the latter indicate that a
* bean was discovered specifically via component-scanning as opposed to other means.
* @param metadata the annotation metadata for the bean | AnnotatedGenericBeanDefinition |
java | google__guava | android/guava/src/com/google/common/base/internal/Finalizer.java | {
"start": 2062,
"end": 3007
} | class ____ implements Runnable {
private static final Logger logger = Logger.getLogger(Finalizer.class.getName());
/** Name of FinalizableReference.class. */
private static final String FINALIZABLE_REFERENCE = "com.google.common.base.FinalizableReference";
/**
* Starts the Finalizer thread. FinalizableReferenceQueue calls this method reflectively.
*
* @param finalizableReferenceClass FinalizableReference.class.
* @param queue a reference queue that the thread will poll.
* @param frqReference a phantom reference to the FinalizableReferenceQueue, which will be queued
* either when the FinalizableReferenceQueue is no longer referenced anywhere, or when its
* close() method is called.
*/
public static void startFinalizer(
Class<?> finalizableReferenceClass,
ReferenceQueue<Object> queue,
PhantomReference<Object> frqReference) {
/*
* We use FinalizableReference. | Finalizer |
java | junit-team__junit5 | junit-vintage-engine/src/main/java/org/junit/vintage/engine/Constants.java | {
"start": 812,
"end": 2924
} | class ____ {
/**
* Indicates whether parallel execution is enabled for the JUnit Vintage engine.
*
* <p>Set this property to {@code true} to enable parallel execution of tests.
* Defaults to {@code false}.
*
* @since 5.12
*/
@API(status = MAINTAINED, since = "5.13.3")
public static final String PARALLEL_EXECUTION_ENABLED = "junit.vintage.execution.parallel.enabled";
/**
* Specifies the size of the thread pool to be used for parallel execution.
*
* <p>Set this property to an integer value to specify the number of threads
* to be used for parallel execution. Defaults to the number of available
* processors.
*
* @since 5.12
*/
@API(status = MAINTAINED, since = "5.13.3")
public static final String PARALLEL_POOL_SIZE = "junit.vintage.execution.parallel.pool-size";
/**
* Indicates whether parallel execution is enabled for test classes in the
* JUnit Vintage engine.
*
* <p>Set this property to {@code true} to enable parallel execution of test
* classes. Defaults to {@code false}.
*
* @since 5.12
*/
@API(status = MAINTAINED, since = "5.13.3")
public static final String PARALLEL_CLASS_EXECUTION = "junit.vintage.execution.parallel.classes";
/**
* Indicates whether parallel execution is enabled for test methods in the
* JUnit Vintage engine.
*
* <p>Set this property to {@code true} to enable parallel execution of test
* methods. Defaults to {@code false}.
*
* @since 5.12
*/
@API(status = MAINTAINED, since = "5.13.3")
public static final String PARALLEL_METHOD_EXECUTION = "junit.vintage.execution.parallel.methods";
/**
* Property name used to configure whether the JUnit Vintage engine should
* report discovery issues such as deprecation notices.
*
* <p>Set this property to {@code false} to disable reporting of discovery
* issues. Defaults to {@code true}.
*
* @since 6.0.1
*/
@API(status = MAINTAINED, since = "6.0.1")
public static final String DISCOVERY_ISSUE_REPORTING_ENABLED_PROPERTY_NAME = "junit.vintage.discovery.issue.reporting.enabled";
private Constants() {
/* no-op */
}
}
| Constants |
java | google__error-prone | core/src/test/java/com/google/errorprone/bugpatterns/time/JavaPeriodGetDaysTest.java | {
"start": 6473,
"end": 6907
} | class ____ {
private final long months = Period.ZERO.getMonths();
private final int days = Period.ZERO.getDays();
}
""")
.doTest();
}
@Test
public void getDaysInFieldInitializer() {
compilationHelper
.addSourceLines(
"test/TestCase.java",
"""
package test;
import java.time.Period;
public | TestCase |
java | quarkusio__quarkus | extensions/security/runtime/src/main/java/io/quarkus/security/runtime/interceptor/SecurityHandler.java | {
"start": 566,
"end": 2108
} | class ____ {
@Inject
SecurityConstrainer constrainer;
public Object handle(InvocationContext ic) throws Exception {
if (alreadyHandled(ic)) {
return ic.proceed();
}
Class<?> returnType = ic.getMethod().getReturnType();
if (Uni.class.isAssignableFrom(returnType)) {
return constrainer.nonBlockingCheck(ic.getMethod(), ic.getParameters())
.onItem().transformToUni(new UniContinuation(ic));
} else if (CompletionStage.class.isAssignableFrom(returnType)) {
return constrainer.nonBlockingCheck(ic.getMethod(), ic.getParameters())
.onItem().transformToUni((s) -> {
try {
return Uni.createFrom().completionStage((CompletionStage<?>) ic.proceed());
} catch (Exception e) {
return Uni.createFrom().failure(e);
}
}).subscribeAsCompletionStage();
} else if (Multi.class.isAssignableFrom(returnType)) {
return constrainer.nonBlockingCheck(ic.getMethod(), ic.getParameters())
.onItem().transformToMulti(new MultiContinuation(ic));
} else {
constrainer.check(ic.getMethod(), ic.getParameters());
return ic.proceed();
}
}
private boolean alreadyHandled(InvocationContext ic) {
return ic.getContextData().put(SECURITY_HANDLER, EXECUTED) != null;
}
private static | SecurityHandler |
java | google__dagger | javatests/dagger/internal/codegen/DelegateRequestRepresentationTest.java | {
"start": 4920,
"end": 6051
} | interface ____ {",
" @Binds @Reusable @Qualifier(RegularScoped.class)",
" Object regular(RegularScoped delegate);",
"",
" @Binds @Reusable @Qualifier(ReusableScoped.class)",
" Object reusable(ReusableScoped delegate);",
"",
" @Binds @Reusable @Qualifier(Unscoped.class)",
" Object unscoped(Unscoped delegate);",
"}");
CompilerTests.daggerCompiler(
module, COMPONENT, QUALIFIER, REGULAR_SCOPED, REUSABLE_SCOPED, UNSCOPED)
.withProcessingOptions(compilerMode.processorOptions())
.compile(
subject -> {
subject.hasErrorCount(0);
subject.generatedSource(goldenFileRule.goldenSource("test/DaggerTestComponent"));
});
}
@Test
public void toUnscoped() throws Exception {
Source module =
CompilerTests.javaSource(
"test.TestModule",
"package test;",
"",
"import dagger.Binds;",
"import dagger.Module;",
"",
"@Module",
" | TestModule |
java | apache__camel | components/camel-test/camel-test-junit5/src/main/java/org/apache/camel/test/junit5/TestLoggerExtension.java | {
"start": 1461,
"end": 3362
} | class ____
implements BeforeEachCallback, AfterEachCallback, BeforeTestExecutionCallback, AfterTestExecutionCallback {
private static final String START_TIME = "start time";
private String currentTestName;
@Override
public void afterEach(ExtensionContext context) throws Exception {
final Class<?> testClass = context.getTestClass().orElse(this.getClass());
StopWatch durationTracker = getStore(context, testClass).remove(START_TIME, StopWatch.class);
Method testMethod = context.getRequiredTestMethod();
if (durationTracker != null) {
testEndFooter(testClass, testMethod.getName(), durationTracker.taken());
} else {
/*
* Extensions may be called twice for Nested methods.
* As such, we ignore the last one as it's related to the
* top-most class: https://github.com/junit-team/junit5/issues/2421
*/
testEndFooter(testClass, testMethod.getName(), 0);
}
}
@Override
public void beforeEach(ExtensionContext context) throws Exception {
currentTestName = context.getDisplayName();
}
@Override
public void afterTestExecution(ExtensionContext context) {
}
@Override
public void beforeTestExecution(ExtensionContext context) {
currentTestName = context.getDisplayName();
final Class<?> testClass = context.getTestClass().orElse(this.getClass());
testStartHeader(testClass, currentTestName);
final ExtensionContext.Store store = getStore(context, testClass);
store.getOrComputeIfAbsent(START_TIME, key -> new StopWatch(), Object.class);
}
private ExtensionContext.Store getStore(ExtensionContext context, Class<?> testClass) {
return context.getStore(Namespace.create(testClass, context.getRequiredTestMethod()));
}
}
| TestLoggerExtension |
java | alibaba__fastjson | src/test/java/com/alibaba/json/bvt/serializer/TestSortField.java | {
"start": 198,
"end": 552
} | class ____ extends TestCase {
public void test_0() throws Exception {
Map<String, Object> map = new LinkedHashMap<String, Object>();
map.put("nnn", "123");
map.put("13", "123");
String text = JSON.toJSONString(map);
Assert.assertEquals("{\"nnn\":\"123\",\"13\":\"123\"}", text);
}
}
| TestSortField |
java | apache__kafka | connect/mirror/src/test/java/org/apache/kafka/connect/mirror/TestUtils.java | {
"start": 1068,
"end": 3739
} | class ____ {
static Map<String, String> makeProps(String... keyValues) {
Map<String, String> props = new HashMap<>();
props.put("name", "ConnectorName");
props.put("connector.class", "ConnectorClass");
props.put("source.cluster.alias", "source1");
props.put("target.cluster.alias", "target2");
for (int i = 0; i < keyValues.length; i += 2) {
props.put(keyValues[i], keyValues[i + 1]);
}
return props;
}
/**
* Assemble a collection of records arbitrarily distributed across all partitions of the specified topic
* @param topicName Destination topic
* @param numRecords count of records to produce to the topic in total
* @return A batch of records that can be sent to a producer.
*/
public static List<ProducerRecord<byte[], byte[]>> generateRecords(String topicName, int numRecords) {
List<ProducerRecord<byte[], byte[]>> records = new ArrayList<>();
for (int i = 0; i < numRecords; i++) {
String key = "key-" + i;
String value = "message-" + i;
records.add(new ProducerRecord<>(topicName, null, key.getBytes(), value.getBytes()));
}
return records;
}
/**
* Assemble a collection of records evenly distributed across some partitions of the specified topic
* @param topicName Destination topic
* @param numRecords count of records to produce to each partition
* @param numPartitions number of partitions within the topic to write records to.
* @return A batch of records that can be sent to a producer.
*/
public static List<ProducerRecord<byte[], byte[]>> generateRecords(String topicName, int numRecords, int numPartitions) {
List<ProducerRecord<byte[], byte[]>> records = new ArrayList<>();
int cnt = 0;
for (int r = 0; r < numRecords; r++) {
for (int p = 0; p < numPartitions; p++) {
String value = "value-" + cnt;
String key = "key-" + cnt;
cnt++;
records.add(new ProducerRecord<>(topicName, p, key.getBytes(), value.getBytes()));
}
}
return records;
}
public static void assertEqualsExceptClientId(Map<String, Object> expected, Map<String, Object> actual) {
Map<String, Object> expectedWithoutClientId = new HashMap<>(expected);
expectedWithoutClientId.remove("client.id");
Map<String, Object> actualWithoutClientId = new HashMap<>(actual);
actualWithoutClientId.remove("client.id");
assertEquals(expectedWithoutClientId, actualWithoutClientId);
}
}
| TestUtils |
java | apache__camel | components/camel-openstack/src/generated/java/org/apache/camel/component/openstack/nova/NovaEndpointConfigurer.java | {
"start": 741,
"end": 3851
} | class ____ extends PropertyConfigurerSupport implements GeneratedPropertyConfigurer, PropertyConfigurerGetter {
@Override
public boolean configure(CamelContext camelContext, Object obj, String name, Object value, boolean ignoreCase) {
NovaEndpoint target = (NovaEndpoint) obj;
switch (ignoreCase ? name.toLowerCase() : name) {
case "apiversion":
case "apiVersion": target.setApiVersion(property(camelContext, java.lang.String.class, value)); return true;
case "config": target.setConfig(property(camelContext, org.openstack4j.core.transport.Config.class, value)); return true;
case "domain": target.setDomain(property(camelContext, java.lang.String.class, value)); return true;
case "lazystartproducer":
case "lazyStartProducer": target.setLazyStartProducer(property(camelContext, boolean.class, value)); return true;
case "operation": target.setOperation(property(camelContext, java.lang.String.class, value)); return true;
case "password": target.setPassword(property(camelContext, java.lang.String.class, value)); return true;
case "project": target.setProject(property(camelContext, java.lang.String.class, value)); return true;
case "subsystem": target.setSubsystem(property(camelContext, java.lang.String.class, value)); return true;
case "username": target.setUsername(property(camelContext, java.lang.String.class, value)); return true;
default: return false;
}
}
@Override
public Class<?> getOptionType(String name, boolean ignoreCase) {
switch (ignoreCase ? name.toLowerCase() : name) {
case "apiversion":
case "apiVersion": return java.lang.String.class;
case "config": return org.openstack4j.core.transport.Config.class;
case "domain": return java.lang.String.class;
case "lazystartproducer":
case "lazyStartProducer": return boolean.class;
case "operation": return java.lang.String.class;
case "password": return java.lang.String.class;
case "project": return java.lang.String.class;
case "subsystem": return java.lang.String.class;
case "username": return java.lang.String.class;
default: return null;
}
}
@Override
public Object getOptionValue(Object obj, String name, boolean ignoreCase) {
NovaEndpoint target = (NovaEndpoint) obj;
switch (ignoreCase ? name.toLowerCase() : name) {
case "apiversion":
case "apiVersion": return target.getApiVersion();
case "config": return target.getConfig();
case "domain": return target.getDomain();
case "lazystartproducer":
case "lazyStartProducer": return target.isLazyStartProducer();
case "operation": return target.getOperation();
case "password": return target.getPassword();
case "project": return target.getProject();
case "subsystem": return target.getSubsystem();
case "username": return target.getUsername();
default: return null;
}
}
}
| NovaEndpointConfigurer |
java | google__guava | android/guava-tests/test/com/google/common/escape/ArrayBasedUnicodeEscaperTest.java | {
"start": 1103,
"end": 5294
} | class ____ extends TestCase {
private static final ImmutableMap<Character, String> NO_REPLACEMENTS = ImmutableMap.of();
private static final ImmutableMap<Character, String> SIMPLE_REPLACEMENTS =
ImmutableMap.of(
'\n', "<newline>",
'\t', "<tab>",
'&', "<and>");
private static final char[] NO_CHARS = new char[0];
public void testReplacements() throws IOException {
// In reality this is not a very sensible escaper to have (if you are only
// escaping elements from a map you would use a ArrayBasedCharEscaper).
UnicodeEscaper escaper =
new ArrayBasedUnicodeEscaper(
SIMPLE_REPLACEMENTS, Character.MIN_VALUE, Character.MAX_CODE_POINT, null) {
@Override
protected char[] escapeUnsafe(int c) {
return NO_CHARS;
}
};
EscaperAsserts.assertBasic(escaper);
assertThat(escaper.escape("\tFish & Chips\n")).isEqualTo("<tab>Fish <and> Chips<newline>");
// Verify that everything else is left unescaped.
String safeChars = "\0\u0100\uD800\uDC00\uFFFF";
assertThat(escaper.escape(safeChars)).isEqualTo(safeChars);
// Ensure that Unicode escapers behave correctly wrt badly formed input.
String badUnicode = "\uDC00\uD800";
assertThrows(IllegalArgumentException.class, () -> escaper.escape(badUnicode));
}
public void testSafeRange() throws IOException {
// Basic escaping of unsafe chars (wrap them in {,}'s)
UnicodeEscaper wrappingEscaper =
new ArrayBasedUnicodeEscaper(NO_REPLACEMENTS, 'A', 'Z', null) {
@Override
protected char[] escapeUnsafe(int c) {
return ("{" + (char) c + "}").toCharArray();
}
};
EscaperAsserts.assertBasic(wrappingEscaper);
// '[' and '@' lie either side of [A-Z].
assertThat(wrappingEscaper.escape("[FOO@BAR]")).isEqualTo("{[}FOO{@}BAR{]}");
}
public void testDeleteUnsafeChars() throws IOException {
UnicodeEscaper deletingEscaper =
new ArrayBasedUnicodeEscaper(NO_REPLACEMENTS, ' ', '~', null) {
@Override
protected char[] escapeUnsafe(int c) {
return NO_CHARS;
}
};
EscaperAsserts.assertBasic(deletingEscaper);
assertThat(
deletingEscaper.escape(
"\tEverything\0 outside the\uD800\uDC00 "
+ "printable ASCII \uFFFFrange is \u007Fdeleted.\n"))
.isEqualTo("Everything outside the printable ASCII range is deleted.");
}
public void testReplacementPriority() throws IOException {
UnicodeEscaper replacingEscaper =
new ArrayBasedUnicodeEscaper(SIMPLE_REPLACEMENTS, ' ', '~', null) {
private final char[] unknown = new char[] {'?'};
@Override
protected char[] escapeUnsafe(int c) {
return unknown;
}
};
EscaperAsserts.assertBasic(replacingEscaper);
// Replacements are applied first regardless of whether the character is in
// the safe range or not ('&' is a safe char while '\t' and '\n' are not).
assertThat(replacingEscaper.escape("\tFish &\0 Chips\r\n"))
.isEqualTo("<tab>Fish <and>? Chips?<newline>");
}
public void testCodePointsFromSurrogatePairs() throws IOException {
UnicodeEscaper surrogateEscaper =
new ArrayBasedUnicodeEscaper(NO_REPLACEMENTS, 0, 0x20000, null) {
private final char[] escaped = new char[] {'X'};
@Override
protected char[] escapeUnsafe(int c) {
return escaped;
}
};
EscaperAsserts.assertBasic(surrogateEscaper);
// A surrogate pair defining a code point within the safe range.
String safeInput = "\uD800\uDC00"; // 0x10000
assertThat(surrogateEscaper.escape(safeInput)).isEqualTo(safeInput);
// A surrogate pair defining a code point outside the safe range (but both
// of the surrogate characters lie within the safe range). It is important
// not to accidentally treat this as a sequence of safe characters.
String unsafeInput = "\uDBFF\uDFFF"; // 0x10FFFF
assertThat(surrogateEscaper.escape(unsafeInput)).isEqualTo("X");
}
}
| ArrayBasedUnicodeEscaperTest |
java | junit-team__junit5 | platform-tests/src/test/java/org/junit/platform/suite/engine/testsuites/LifecycleMethodsSuites.java | {
"start": 4427,
"end": 4573
} | class ____ {
@BeforeSuite
void nonStaticBeforeSuite() {
fail("Should not be called");
}
}
@TestSuite
public static | NonStaticBeforeSuite |
java | quarkusio__quarkus | independent-projects/bootstrap/core/src/test/java/io/quarkus/bootstrap/classloader/InterruptClass.java | {
"start": 50,
"end": 377
} | class ____ implements Runnable {
@Override
public void run() {
try {
Thread.currentThread().interrupt();
Class.forName("io.quarkus.bootstrap.classloader.ClassToLoad");
} catch (ClassNotFoundException ex) {
throw new RuntimeException(ex);
}
}
}
| InterruptClass |
java | mybatis__mybatis-3 | src/test/java/org/apache/ibatis/submitted/literal_string/LiteralStringTest.java | {
"start": 1099,
"end": 2531
} | class ____ {
private static SqlSessionFactory sqlSessionFactory;
@BeforeAll
static void setUp() throws Exception {
// create an SqlSessionFactory
try (Reader reader = Resources
.getResourceAsReader("org/apache/ibatis/submitted/literal_string/mybatis-config.xml")) {
sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);
}
// populate in-memory database
BaseDataTest.runScript(sqlSessionFactory.getConfiguration().getEnvironment().getDataSource(),
"org/apache/ibatis/submitted/literal_string/CreateDB.sql");
}
@Test
void shouldRetainControlCharactersInMapper() {
try (SqlSession sqlSession = sqlSessionFactory.openSession()) {
Mapper mapper = sqlSession.getMapper(Mapper.class);
mapper.insert(1);
assertEquals("\ta b\r\n\tc\n", mapper.select(1));
}
}
@Test
void shouldRetainControlCharactersInMapperScript() {
try (SqlSession sqlSession = sqlSessionFactory.openSession()) {
Mapper mapper = sqlSession.getMapper(Mapper.class);
mapper.insertScript(2);
assertEquals("\ta b\r\n\tc\n", mapper.select(2));
}
}
@Test
void shouldRetainControlCharactersInMapperXml() {
try (SqlSession sqlSession = sqlSessionFactory.openSession()) {
Mapper mapper = sqlSession.getMapper(Mapper.class);
mapper.insertXml(3);
assertEquals("\ta b\r\n\tc\n", mapper.select(3));
}
}
}
| LiteralStringTest |
java | FasterXML__jackson-core | src/main/java/tools/jackson/core/json/JsonParserBase.java | {
"start": 480,
"end": 16482
} | class ____
extends ParserBase
{
private final static char[] NO_CHARS = new char[0];
/*
/**********************************************************************
/* JSON-specific configuration
/**********************************************************************
*/
/**
* Bit flag for {@link JsonReadFeature}s that are enabled.
*/
protected int _formatReadFeatures;
/*
/**********************************************************************
/* Parsing state
/**********************************************************************
*/
/**
* Information about parser context, context in which
* the next token is to be parsed (root, array, object).
*/
protected JsonReadContext _streamReadContext;
/**
* Secondary token related to the next token after current one;
* used if its type is known. This may be value token that
* follows {@link JsonToken#PROPERTY_NAME}, for example.
*/
protected JsonToken _nextToken;
/*
/**********************************************************************
/* Helper buffer recycling
/**********************************************************************
*/
/**
* Temporary buffer that is needed if an Object property name is accessed
* using {@link #getTextCharacters} method (instead of String
* returning alternatives)
*/
private char[] _nameCopyBuffer = NO_CHARS;
/**
* Flag set to indicate whether the Object property name is available
* from the name copy buffer or not (in addition to its String
* representation being available via read context)
*/
protected boolean _nameCopied;
/*
/**********************************************************************
/* Life-cycle
/**********************************************************************
*/
protected JsonParserBase(ObjectReadContext readCtxt,
IOContext ctxt, int streamReadFeatures, int formatReadFeatures) {
super(readCtxt, ctxt, streamReadFeatures);
_formatReadFeatures = formatReadFeatures;
DupDetector dups = StreamReadFeature.STRICT_DUPLICATE_DETECTION.enabledIn(streamReadFeatures)
? DupDetector.rootDetector(this) : null;
_streamReadContext = JsonReadContext.createRootContext(dups);
}
/*
/**********************************************************************
/* Versioned, capabilities, config
/**********************************************************************
*/
@Override public Version version() { return PackageVersion.VERSION; }
@Override
public JacksonFeatureSet<StreamReadCapability> streamReadCapabilities() {
// For now, JSON settings do not differ from general defaults:
return DEFAULT_READ_CAPABILITIES;
}
/*
/**********************************************************************
/* ParserBase method implementions/overrides
/**********************************************************************
*/
@Override public TokenStreamContext streamReadContext() { return _streamReadContext; }
@Override
public Object currentValue() {
return _streamReadContext.currentValue();
}
@Override
public void assignCurrentValue(Object v) {
_streamReadContext.assignCurrentValue(v);
}
/**
* Method that can be called to get the name associated with
* the current event.
*/
@Override public String currentName() {
// [JACKSON-395]: start markers require information from parent
if (_currToken == JsonToken.START_OBJECT || _currToken == JsonToken.START_ARRAY) {
JsonReadContext parent = _streamReadContext.getParent();
if (parent != null) {
return parent.currentName();
}
}
return _streamReadContext.currentName();
}
@Override
public boolean hasStringCharacters() {
if (_currToken == JsonToken.VALUE_STRING) { return true; } // usually true
if (_currToken == JsonToken.PROPERTY_NAME) { return _nameCopied; }
return false;
}
// 03-Nov-2019, tatu: Will not recycle "name copy buffer" any more as it seems
// unlikely to be of much real benefit
/*
@Override
protected void _releaseBuffers() {
super._releaseBuffers();
char[] buf = _nameCopyBuffer;
if (buf != null) {
_nameCopyBuffer = null;
_ioContext.releaseNameCopyBuffer(buf);
}
}
*/
/*
/**********************************************************************
/* Internal/package methods: Context handling
/**********************************************************************
*/
protected void createChildArrayContext(final int lineNr, final int colNr) throws JacksonException {
_streamReadContext = _streamReadContext.createChildArrayContext(lineNr, colNr);
_streamReadConstraints.validateNestingDepth(_streamReadContext.getNestingDepth());
}
protected void createChildObjectContext(final int lineNr, final int colNr) throws JacksonException {
_streamReadContext = _streamReadContext.createChildObjectContext(lineNr, colNr);
_streamReadConstraints.validateNestingDepth(_streamReadContext.getNestingDepth());
}
/*
/**********************************************************************
/* Numeric parsing method implementations
/**********************************************************************
*/
@Override
protected void _parseNumericValue(int expType)
throws JacksonException, InputCoercionException
{
// Int or float?
if (_currToken == JsonToken.VALUE_NUMBER_INT) {
int len = _intLength;
// First: optimization for simple int
if (len <= 9) {
int i = _textBuffer.contentsAsInt(_numberNegative);
_numberInt = i;
_numTypesValid = NR_INT;
return;
}
if (len <= 18) { // definitely fits AND is easy to parse using 2 int parse calls
long l = _textBuffer.contentsAsLong(_numberNegative);
// Might still fit in int, need to check
if (len == 10) {
if (_numberNegative) {
if (l >= MIN_INT_L) {
_numberInt = (int) l;
_numTypesValid = NR_INT;
return;
}
} else {
if (l <= MAX_INT_L) {
_numberInt = (int) l;
_numTypesValid = NR_INT;
return;
}
}
}
_numberLong = l;
_numTypesValid = NR_LONG;
return;
}
// For [core#865]: handle remaining 19-char cases as well
if (len == 19) {
char[] buf = _textBuffer.getTextBuffer();
int offset = _textBuffer.getTextOffset();
if (_numberNegative) {
++offset;
}
if (NumberInput.inLongRange(buf, offset, len, _numberNegative)) {
_numberLong = NumberInput.parseLong19(buf, offset, _numberNegative);
_numTypesValid = NR_LONG;
return;
}
}
_parseSlowInt(expType);
return;
}
if (_currToken == JsonToken.VALUE_NUMBER_FLOAT) {
_parseSlowFloat(expType);
return;
}
throw _constructNotNumericType(_currToken, expType);
}
@Override
protected int _parseIntValue() throws JacksonException
{
// Inlined variant of: _parseNumericValue(NR_INT)
if (_currToken == JsonToken.VALUE_NUMBER_INT) {
if (_intLength <= 9) {
int i = _textBuffer.contentsAsInt(_numberNegative);
_numberInt = i;
_numTypesValid = NR_INT;
return i;
}
}
// if not optimizable, use more generic
_parseNumericValue(NR_INT);
if ((_numTypesValid & NR_INT) == 0) {
convertNumberToInt();
}
return _numberInt;
}
private void _parseSlowFloat(int expType) throws JacksonException
{
/* Nope: floating point. Here we need to be careful to get
* optimal parsing strategy: choice is between accurate but
* slow (BigDecimal) and lossy but fast (Double). For now
* let's only use BD when explicitly requested -- it can
* still be constructed correctly at any point since we do
* retain textual representation
*/
if (expType == NR_BIGDECIMAL) {
// 04-Dec-2022, tatu: Let's defer actual decoding until it is certain
// value is actually needed.
// 24-Jun-2024, tatu: No; we shouldn't have to defer unless specifically
// request w/ `getNumberValueDeferred()` or so
_numberBigDecimal = _textBuffer.contentsAsDecimal(isEnabled(StreamReadFeature.USE_FAST_BIG_NUMBER_PARSER));
_numTypesValid = NR_BIGDECIMAL;
} else if (expType == NR_DOUBLE) {
_numberDouble = _textBuffer.contentsAsDouble(isEnabled(StreamReadFeature.USE_FAST_DOUBLE_PARSER));
_numTypesValid = NR_DOUBLE;
} else if (expType == NR_FLOAT) {
_numberFloat = _textBuffer.contentsAsFloat(isEnabled(StreamReadFeature.USE_FAST_DOUBLE_PARSER));
_numTypesValid = NR_FLOAT;
} else { // NR_UNKOWN, or one of int types
// 04-Dec-2022, tatu: We can get all kinds of values here
// (NR_INT, NR_LONG or even NR_UNKNOWN). Should we try further
// deferring some typing?
_numberDouble = 0.0;
_numberString = _textBuffer.contentsAsString();
_numTypesValid = NR_DOUBLE;
}
}
private void _parseSlowInt(int expType) throws JacksonException
{
final String numStr = _textBuffer.contentsAsString();
// 16-Oct-2018, tatu: Need to catch "too big" early due to [jackson-core#488]
if ((expType == NR_INT) || (expType == NR_LONG)) {
_reportTooLongIntegral(expType, numStr);
}
if ((expType == NR_DOUBLE) || (expType == NR_FLOAT)) {
_numberString = numStr;
_numTypesValid = NR_DOUBLE;
} else {
// nope, need the heavy guns... (rare case) - since Jackson v2.14, BigInteger parsing is lazy
_numberBigInt = null;
_numberString = numStr;
_numTypesValid = NR_BIGINT;
}
}
protected void _reportTooLongIntegral(int expType, String rawNum) throws JacksonException
{
if (expType == NR_INT) {
_reportOverflowInt(rawNum);
}
_reportOverflowLong(rawNum);
}
/*
/**********************************************************************
/* Internal/package methods: config access
/**********************************************************************
*/
public boolean isEnabled(JsonReadFeature f) { return f.enabledIn(_formatReadFeatures); }
/*
/**********************************************************************
/* Internal/package methods: buffer handling
/**********************************************************************
*/
protected char[] currentNameInBuffer() {
if (_nameCopied) {
return _nameCopyBuffer;
}
final String name = _streamReadContext.currentName();
final int nameLen = name.length();
if (_nameCopyBuffer.length < nameLen) {
_nameCopyBuffer = new char[Math.max(32, nameLen)];
}
name.getChars(0, nameLen, _nameCopyBuffer, 0);
_nameCopied = true;
return _nameCopyBuffer;
}
/*
/**********************************************************************
/* Internal/package methods: Error reporting
/**********************************************************************
*/
protected char _handleUnrecognizedCharacterEscape(char ch) throws StreamReadException {
// It is possible we allow all kinds of non-standard escapes...
if (isEnabled(JsonReadFeature.ALLOW_BACKSLASH_ESCAPING_ANY_CHARACTER)) {
return ch;
}
// and if allowing single-quoted names, String values, single-quote needs to be escapable regardless
if (ch == '\'' && isEnabled(JsonReadFeature.ALLOW_SINGLE_QUOTES)) {
return ch;
}
throw _constructReadException("Unrecognized character escape "+_getCharDesc(ch),
_currentLocationMinusOne());
}
// Promoted from `ParserBase` in 3.0
protected void _reportMismatchedEndMarker(int actCh, char expCh) throws StreamReadException {
final TokenStreamContext ctxt = streamReadContext();
// 31-Jan-2025, tatu: [core#1394] Need to check case of no open scope
if (ctxt.inRoot()) {
_reportExtraEndMarker(actCh);
return;
}
final String msg = String.format(
"Unexpected close marker '%s': expected '%c' (for %s starting at %s)",
(char) actCh, expCh, ctxt.typeDesc(), ctxt.startLocation(_contentReference()));
throw _constructReadException(msg, _currentLocationMinusOne());
}
protected void _reportExtraEndMarker(int actCh) throws StreamReadException {
final String scopeDesc = (actCh == '}') ? "Object" : "Array";
final String msg = String.format(
"Unexpected close marker '%s': no open %s to close", (char) actCh, scopeDesc);
throw _constructReadException(msg, _currentLocationMinusOne());
}
// Method called to report a problem with unquoted control character.
// Note: it is possible to suppress some instances of
// exception by enabling {@link JsonReadFeature#ALLOW_UNESCAPED_CONTROL_CHARS}.
protected void _throwUnquotedSpace(int i, String ctxtDesc) throws StreamReadException {
// It is possible to allow unquoted control chars:
if (!isEnabled(JsonReadFeature.ALLOW_UNESCAPED_CONTROL_CHARS) || i > INT_SPACE) {
char c = (char) i;
String msg = "Illegal unquoted character ("+_getCharDesc(c)+"): has to be escaped using backslash to be included in "+ctxtDesc;
throw _constructReadException(msg, _currentLocationMinusOne());
}
}
// @return Description to use as "valid tokens" in an exception message about
// invalid (unrecognized) JSON token: called when parser finds something that
// looks like unquoted textual token
protected String _validJsonTokenList() {
return _validJsonValueList();
}
// @return Description to use as "valid JSON values" in an exception message about
// invalid (unrecognized) JSON value: called when parser finds something that
// does not look like a value or separator.
protected String _validJsonValueList() {
if (isEnabled(JsonReadFeature.ALLOW_NON_NUMERIC_NUMBERS)) {
return "(JSON String, Number (or 'NaN'/'+INF'/'-INF'), Array, Object or token 'null', 'true' or 'false')";
}
return "(JSON String, Number, Array, Object or token 'null', 'true' or 'false')";
}
/*
/**********************************************************************
/* Internal/package methods: other
/**********************************************************************
*/
protected boolean _isAllowedCtrlCharRS(int i) {
return (i == INT_RS) && JsonReadFeature.ALLOW_RS_CONTROL_CHAR.enabledIn(_formatReadFeatures);
}
}
| JsonParserBase |
java | apache__camel | components/camel-zookeeper/src/main/java/org/apache/camel/component/zookeeper/operations/ExistenceChangedOperation.java | {
"start": 1170,
"end": 2139
} | class ____ extends FutureEventDrivenOperation<String> {
public ExistenceChangedOperation(ZooKeeper connection, String znode) {
super(connection, znode, EventType.NodeCreated, EventType.NodeDeleted);
}
@Override
protected void installWatch() {
connection.exists(getNode(), this, (int rc, String path, Object ctx, Stat stat) -> {
}, null);
if (LOG.isDebugEnabled()) {
LOG.debug("Installed exists watch");
}
}
@Override
public OperationResult<String> getResult() {
try {
String path = getNode();
Stat statistics = connection.exists(path, true);
return new OperationResult<>(path, statistics);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
return new OperationResult<>(e);
} catch (Exception e) {
return new OperationResult<>(e);
}
}
}
| ExistenceChangedOperation |
java | alibaba__druid | core/src/main/java/com/alibaba/druid/sql/dialect/mysql/ast/expr/MySqlOrderingExpr.java | {
"start": 951,
"end": 3331
} | class ____ extends MySqlExprImpl implements MySqlExpr, SQLReplaceable {
protected SQLExpr expr;
protected SQLOrderingSpecification type;
public MySqlOrderingExpr() {
}
public MySqlOrderingExpr(SQLExpr expr, SQLOrderingSpecification type) {
super();
setExpr(expr);
this.type = type;
}
public MySqlOrderingExpr clone() {
MySqlOrderingExpr x = new MySqlOrderingExpr();
if (expr != null) {
x.setExpr(expr.clone());
}
x.type = type;
return x;
}
@Override
public boolean replace(SQLExpr expr, SQLExpr target) {
if (this.expr == expr) {
setExpr(target);
return true;
}
return false;
}
@Override
public void accept0(MySqlASTVisitor mysqlVisitor) {
if (mysqlVisitor.visit(this)) {
if (expr != null) {
expr.accept(mysqlVisitor);
}
}
mysqlVisitor.endVisit(this);
}
@Override
public List getChildren() {
return Collections.singletonList(this.expr);
}
public SQLExpr getExpr() {
return expr;
}
public void setExpr(SQLExpr expr) {
if (expr != null) {
expr.setParent(this);
}
this.expr = expr;
}
public SQLOrderingSpecification getType() {
return type;
}
public void setType(SQLOrderingSpecification type) {
this.type = type;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
MySqlOrderingExpr other = (MySqlOrderingExpr) obj;
if (expr != other.expr) {
return false;
}
if (type == null) {
if (other.type != null) {
return false;
}
} else if (!type.equals(other.type)) {
return false;
}
return true;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((expr == null) ? 0 : expr.hashCode());
result = prime * result + ((type == null) ? 0 : type.hashCode());
return result;
}
}
| MySqlOrderingExpr |
java | apache__kafka | clients/src/main/java/org/apache/kafka/clients/admin/AlterStreamsGroupOffsetsResult.java | {
"start": 1224,
"end": 1853
} | class ____ {
private final AlterConsumerGroupOffsetsResult delegate;
AlterStreamsGroupOffsetsResult(final AlterConsumerGroupOffsetsResult delegate) {
this.delegate = delegate;
}
/**
* Return a future which can be used to check the result for a given partition.
*/
public KafkaFuture<Void> partitionResult(final TopicPartition partition) {
return delegate.partitionResult(partition);
}
/**
* Return a future which succeeds if all the alter offsets succeed.
*/
public KafkaFuture<Void> all() {
return delegate.all();
}
}
| AlterStreamsGroupOffsetsResult |
java | apache__camel | components/camel-ftp/src/test/java/org/apache/camel/component/file/remote/manual/FtpConsumerScottManualTest.java | {
"start": 1248,
"end": 1889
} | class ____ extends CamelTestSupport {
@TempDir
Path testDirectory;
@Test
public void testFtpConsumerManual() throws Exception {
getMockEndpoint("mock:result").expectedMessageCount(1);
MockEndpoint.assertIsSatisfied(context);
}
@Override
protected RouteBuilder createRouteBuilder() {
return new RouteBuilder() {
@Override
public void configure() {
from("ftp:localhost?username=scott&password=tiger&noop=true").to(TestSupport.fileUri(testDirectory))
.to("mock:result");
}
};
}
}
| FtpConsumerScottManualTest |
java | bumptech__glide | annotation/compiler/test/src/test/resources/EmptyAppGlideModuleTest/GlideRequests.java | {
"start": 981,
"end": 4613
} | class ____ extends RequestManager {
public GlideRequests(@NonNull Glide glide, @NonNull Lifecycle lifecycle,
@NonNull RequestManagerTreeNode treeNode, @NonNull Context context) {
super(glide, lifecycle, treeNode, context);
}
@Override
@CheckResult
@NonNull
public <ResourceType> GlideRequest<ResourceType> as(@NonNull Class<ResourceType> resourceClass) {
return new GlideRequest<>(glide, this, resourceClass, context);
}
@Override
@NonNull
public synchronized GlideRequests applyDefaultRequestOptions(@NonNull RequestOptions options) {
return (GlideRequests) super.applyDefaultRequestOptions(options);
}
@Override
@NonNull
public synchronized GlideRequests setDefaultRequestOptions(@NonNull RequestOptions options) {
return (GlideRequests) super.setDefaultRequestOptions(options);
}
@Override
@NonNull
public GlideRequests addDefaultRequestListener(RequestListener<Object> listener) {
return (GlideRequests) super.addDefaultRequestListener(listener);
}
@Override
@NonNull
@CheckResult
public GlideRequest<Bitmap> asBitmap() {
return (GlideRequest<Bitmap>) super.asBitmap();
}
@Override
@NonNull
@CheckResult
public GlideRequest<GifDrawable> asGif() {
return (GlideRequest<GifDrawable>) super.asGif();
}
@Override
@NonNull
@CheckResult
public GlideRequest<Drawable> asDrawable() {
return (GlideRequest<Drawable>) super.asDrawable();
}
@Override
@NonNull
@CheckResult
public GlideRequest<Drawable> load(@Nullable Bitmap bitmap) {
return (GlideRequest<Drawable>) super.load(bitmap);
}
@Override
@NonNull
@CheckResult
public GlideRequest<Drawable> load(@Nullable Drawable drawable) {
return (GlideRequest<Drawable>) super.load(drawable);
}
@Override
@NonNull
@CheckResult
public GlideRequest<Drawable> load(@Nullable String string) {
return (GlideRequest<Drawable>) super.load(string);
}
@Override
@NonNull
@CheckResult
public GlideRequest<Drawable> load(@Nullable Uri uri) {
return (GlideRequest<Drawable>) super.load(uri);
}
@Override
@NonNull
@CheckResult
public GlideRequest<Drawable> load(@Nullable File file) {
return (GlideRequest<Drawable>) super.load(file);
}
@Override
@NonNull
@CheckResult
public GlideRequest<Drawable> load(@RawRes @DrawableRes @Nullable Integer id) {
return (GlideRequest<Drawable>) super.load(id);
}
@Override
@Deprecated
@CheckResult
public GlideRequest<Drawable> load(@Nullable URL url) {
return (GlideRequest<Drawable>) super.load(url);
}
@Override
@NonNull
@CheckResult
public GlideRequest<Drawable> load(@Nullable byte[] bytes) {
return (GlideRequest<Drawable>) super.load(bytes);
}
@Override
@NonNull
@CheckResult
public GlideRequest<Drawable> load(@Nullable Object o) {
return (GlideRequest<Drawable>) super.load(o);
}
@Override
@NonNull
@CheckResult
public GlideRequest<File> downloadOnly() {
return (GlideRequest<File>) super.downloadOnly();
}
@Override
@NonNull
@CheckResult
public GlideRequest<File> download(@Nullable Object o) {
return (GlideRequest<File>) super.download(o);
}
@Override
@NonNull
@CheckResult
public GlideRequest<File> asFile() {
return (GlideRequest<File>) super.asFile();
}
@Override
protected void setRequestOptions(@NonNull RequestOptions toSet) {
if (toSet instanceof com.bumptech.glide.test.GlideOptions) {
super.setRequestOptions(toSet);
} else {
super.setRequestOptions(new com.bumptech.glide.test.GlideOptions().apply(toSet));
}
}
}
| GlideRequests |
java | hibernate__hibernate-orm | hibernate-core/src/main/java/org/hibernate/sql/model/ast/CustomSqlMutation.java | {
"start": 233,
"end": 513
} | interface ____<O extends JdbcMutationOperation> extends TableMutation<O> {
/**
* The custom SQL provided by the mapping
*/
String getCustomSql();
/**
* Whether {@link #getCustomSql()} represents a callable (function/procedure)
*/
boolean isCallable();
}
| CustomSqlMutation |
java | spring-projects__spring-framework | spring-expression/src/test/java/org/springframework/expression/spel/IndexingTests.java | {
"start": 31860,
"end": 32162
} | class ____ extends ReflectiveIndexAccessor {
ColorCollectionIndexAccessor() {
super(ColorCollection.class, int.class, "get");
}
}
/**
* {@link IndexAccessor} that knows how to read and write indexes in a
* Jackson {@link ArrayNode}.
*/
private static | ColorCollectionIndexAccessor |
java | elastic__elasticsearch | server/src/main/java/org/elasticsearch/action/search/AbstractSearchAsyncAction.java | {
"start": 3624,
"end": 39489
} | class ____<Result extends SearchPhaseResult> extends SearchPhase {
protected static final float DEFAULT_INDEX_BOOST = 1.0f;
private final Logger logger;
private final NamedWriteableRegistry namedWriteableRegistry;
protected final SearchTransportService searchTransportService;
private final Executor executor;
private final ActionListener<SearchResponse> listener;
protected final SearchRequest request;
/**
* Used by subclasses to resolve node ids to DiscoveryNodes.
**/
private final BiFunction<String, String, Transport.Connection> nodeIdToConnection;
protected final SearchTask task;
protected final SearchPhaseResults<Result> results;
private final long clusterStateVersion;
protected final Map<String, AliasFilter> aliasFilter;
protected final Map<String, Float> concreteIndexBoosts;
private final SetOnce<AtomicArray<ShardSearchFailure>> shardFailures = new SetOnce<>();
private final AtomicBoolean hasShardResponse = new AtomicBoolean(false);
private final AtomicInteger successfulOps;
protected final SearchTimeProvider timeProvider;
private final SearchResponse.Clusters clusters;
protected final List<SearchShardIterator> shardsIts;
protected final SearchShardIterator[] shardIterators;
private final AtomicInteger outstandingShards;
private final int maxConcurrentRequestsPerNode;
private final Map<String, PendingExecutions> pendingExecutionsPerNode;
private final AtomicBoolean requestCancelled = new AtomicBoolean();
private final int skippedCount;
private final TransportVersion mintransportVersion;
protected final SearchResponseMetrics searchResponseMetrics;
protected final Map<String, Object> searchRequestAttributes;
protected long phaseStartTimeInNanos;
// protected for tests
protected final SubscribableListener<Void> doneFuture = new SubscribableListener<>();
private final Supplier<DiscoveryNodes> discoveryNodes;
AbstractSearchAsyncAction(
String name,
Logger logger,
NamedWriteableRegistry namedWriteableRegistry,
SearchTransportService searchTransportService,
BiFunction<String, String, Transport.Connection> nodeIdToConnection,
Map<String, AliasFilter> aliasFilter,
Map<String, Float> concreteIndexBoosts,
Executor executor,
SearchRequest request,
ActionListener<SearchResponse> listener,
List<SearchShardIterator> shardsIts,
SearchTimeProvider timeProvider,
ClusterState clusterState,
SearchTask task,
SearchPhaseResults<Result> resultConsumer,
int maxConcurrentRequestsPerNode,
SearchResponse.Clusters clusters,
SearchResponseMetrics searchResponseMetrics,
Map<String, Object> searchRequestAttributes
) {
super(name);
this.namedWriteableRegistry = namedWriteableRegistry;
final List<SearchShardIterator> iterators = new ArrayList<>();
int skipped = 0;
for (final SearchShardIterator iterator : shardsIts) {
if (iterator.skip()) {
skipped++;
} else {
iterators.add(iterator);
}
}
this.skippedCount = skipped;
this.shardsIts = iterators;
outstandingShards = new AtomicInteger(iterators.size());
successfulOps = new AtomicInteger(skipped);
this.shardIterators = iterators.toArray(new SearchShardIterator[0]);
// we later compute the shard index based on the natural order of the shards
// that participate in the search request. This means that this number is
// consistent between two requests that target the same shards.
Arrays.sort(shardIterators);
this.maxConcurrentRequestsPerNode = maxConcurrentRequestsPerNode;
// in the case were we have less shards than maxConcurrentRequestsPerNode we don't need to throttle
this.pendingExecutionsPerNode = maxConcurrentRequestsPerNode < shardsIts.size() ? new ConcurrentHashMap<>() : null;
this.timeProvider = timeProvider;
this.logger = logger;
this.searchTransportService = searchTransportService;
this.executor = executor;
this.request = request;
this.task = task;
this.listener = ActionListener.runBefore(listener, () -> doneFuture.onResponse(null));
this.nodeIdToConnection = nodeIdToConnection;
this.concreteIndexBoosts = concreteIndexBoosts;
this.clusterStateVersion = clusterState.version();
this.mintransportVersion = clusterState.getMinTransportVersion();
this.discoveryNodes = clusterState::nodes;
this.aliasFilter = aliasFilter;
this.results = resultConsumer;
// register the release of the query consumer to free up the circuit breaker memory
// at the end of the search
addReleasable(resultConsumer);
this.clusters = clusters;
this.searchResponseMetrics = searchResponseMetrics;
this.searchRequestAttributes = searchRequestAttributes;
}
protected void notifyListShards(
SearchProgressListener progressListener,
SearchResponse.Clusters clusters,
SearchRequest searchRequest,
List<SearchShardIterator> allIterators
) {
final List<SearchShard> skipped = new ArrayList<>(allIterators.size() - shardsIts.size());
for (SearchShardIterator iter : allIterators) {
if (iter.skip()) {
skipped.add(new SearchShard(iter.getClusterAlias(), iter.shardId()));
}
}
var sourceBuilder = searchRequest.source();
progressListener.notifyListShards(
SearchProgressListener.buildSearchShardsFromIter(this.shardsIts),
skipped,
clusters,
sourceBuilder == null || sourceBuilder.size() > 0,
timeProvider
);
}
/**
* Registers a {@link Releasable} that will be closed when the search request finishes or fails.
*/
public void addReleasable(Releasable releasable) {
var doneFuture = this.doneFuture;
if (doneFuture.isDone()) {
releasable.close();
} else {
doneFuture.addListener(ActionListener.releasing(releasable));
}
}
/**
* Builds how long it took to execute the search.
*/
long buildTookInMillis() {
return timeProvider.buildTookInMillis();
}
/**
* This is the main entry point for a search. This method starts the search execution of the initial phase.
*/
public final void start() {
if (getNumShards() == 0) {
// no search shards to search on, bail with empty response
// (it happens with search across _all with no indices around and consistent with broadcast operations)
int trackTotalHitsUpTo = request.source() == null ? SearchContext.DEFAULT_TRACK_TOTAL_HITS_UP_TO
: request.source().trackTotalHitsUpTo() == null ? SearchContext.DEFAULT_TRACK_TOTAL_HITS_UP_TO
: request.source().trackTotalHitsUpTo();
// total hits is null in the response if the tracking of total hits is disabled
boolean withTotalHits = trackTotalHitsUpTo != SearchContext.TRACK_TOTAL_HITS_DISABLED;
sendSearchResponse(
withTotalHits ? SearchResponseSections.EMPTY_WITH_TOTAL_HITS : SearchResponseSections.EMPTY_WITHOUT_TOTAL_HITS,
new AtomicArray<>(0)
);
return;
}
executePhase(this);
}
@Override
protected final void run() {
phaseStartTimeInNanos = System.nanoTime();
if (outstandingShards.get() == 0) {
onPhaseDone();
return;
}
final Map<SearchShardIterator, Integer> shardIndexMap = Maps.newHashMapWithExpectedSize(shardIterators.length);
for (int i = 0; i < shardIterators.length; i++) {
shardIndexMap.put(shardIterators[i], i);
}
doRun(shardIndexMap);
}
protected void doRun(Map<SearchShardIterator, Integer> shardIndexMap) {
doCheckNoMissingShards(getName(), request, shardsIts);
for (int i = 0; i < shardsIts.size(); i++) {
final SearchShardIterator shardRoutings = shardsIts.get(i);
assert shardRoutings.skip() == false;
assert shardIndexMap.containsKey(shardRoutings);
int shardIndex = shardIndexMap.get(shardRoutings);
final SearchShardTarget routing = shardRoutings.nextOrNull();
if (routing == null) {
failOnUnavailable(shardIndex, shardRoutings);
} else {
performPhaseOnShard(shardIndex, shardRoutings, routing);
}
}
}
protected final void performPhaseOnShard(final int shardIndex, final SearchShardIterator shardIt, final SearchShardTarget shard) {
var pendingExecutionsPerNode = this.pendingExecutionsPerNode;
if (pendingExecutionsPerNode != null) {
var pendingExecutions = pendingExecutionsPerNode.computeIfAbsent(
shard.getNodeId(),
n -> new PendingExecutions(maxConcurrentRequestsPerNode)
);
pendingExecutions.submit(l -> doPerformPhaseOnShard(shardIndex, shardIt, shard, l));
} else {
doPerformPhaseOnShard(shardIndex, shardIt, shard, () -> {});
}
}
private void doPerformPhaseOnShard(int shardIndex, SearchShardIterator shardIt, SearchShardTarget shard, Releasable releasable) {
var shardListener = new SearchActionListener<Result>(shard, shardIndex) {
@Override
public void innerOnResponse(Result result) {
try {
releasable.close();
onShardResult(result);
} catch (Exception exc) {
onShardFailure(shardIndex, shard, shardIt, exc);
}
}
@Override
public void onFailure(Exception e) {
releasable.close();
onShardFailure(shardIndex, shard, shardIt, e);
}
};
final Transport.Connection connection;
try {
connection = getConnection(shard.getClusterAlias(), shard.getNodeId());
} catch (Exception e) {
shardListener.onFailure(e);
return;
}
executePhaseOnShard(shardIt, connection, shardListener);
}
protected final void failOnUnavailable(int shardIndex, SearchShardIterator shardIt) {
SearchShardTarget unassignedShard = new SearchShardTarget(null, shardIt.shardId(), shardIt.getClusterAlias());
onShardFailure(shardIndex, unassignedShard, shardIt, new NoShardAvailableActionException(shardIt.shardId()));
}
/**
* Sends the request to the actual shard.
* @param shardIt the shards iterator
* @param connection to node that the shard is located on
* @param listener the listener to notify on response
*/
protected abstract void executePhaseOnShard(
SearchShardIterator shardIt,
Transport.Connection connection,
SearchActionListener<Result> listener
);
/**
* Processes the phase transition from on phase to another. This method handles all errors that happen during the initial run execution
* of the next phase. If there are no successful operations in the context when this method is executed the search is aborted and
* a response is returned to the user indicating that all shards have failed.
*/
protected void executeNextPhase(String currentPhase, Supplier<SearchPhase> nextPhaseSupplier) {
/* This is the main search phase transition where we move to the next phase. If all shards
* failed or if there was a failure and partial results are not allowed, then we immediately
* fail. Otherwise we continue to the next phase.
*/
ShardOperationFailedException[] shardSearchFailures = buildShardFailures();
if (shardSearchFailures.length == getNumShards()) {
shardSearchFailures = ExceptionsHelper.groupBy(shardSearchFailures);
Throwable cause = shardSearchFailures.length == 0
? null
: ElasticsearchException.guessRootCauses(shardSearchFailures[0].getCause())[0];
logger.debug(() -> "All shards failed for phase: [" + currentPhase + "]", cause);
onPhaseFailure(currentPhase, "all shards failed", cause);
} else {
Boolean allowPartialResults = request.allowPartialSearchResults();
assert allowPartialResults != null : "SearchRequest missing setting for allowPartialSearchResults";
if (allowPartialResults == false && successfulOps.get() != getNumShards()) {
// check if there are actual failures in the atomic array since
// successful retries can reset the failures to null
if (shardSearchFailures.length > 0) {
if (logger.isDebugEnabled()) {
int numShardFailures = shardSearchFailures.length;
shardSearchFailures = ExceptionsHelper.groupBy(shardSearchFailures);
Throwable cause = ElasticsearchException.guessRootCauses(shardSearchFailures[0].getCause())[0];
logger.debug(() -> format("%s shards failed for phase: [%s]", numShardFailures, currentPhase), cause);
}
onPhaseFailure(currentPhase, "Partial shards failure", null);
} else {
int discrepancy = getNumShards() - successfulOps.get();
assert discrepancy > 0 : "discrepancy: " + discrepancy;
if (logger.isDebugEnabled()) {
logger.debug(
"Partial shards failure (unavailable: {}, successful: {}, skipped: {}, num-shards: {}, phase: {})",
discrepancy,
successfulOps.get(),
skippedCount,
getNumShards(),
currentPhase
);
}
onPhaseFailure(currentPhase, "Partial shards failure (" + discrepancy + " shards unavailable)", null);
}
return;
}
var nextPhase = nextPhaseSupplier.get();
if (logger.isTraceEnabled()) {
final String resultsFrom = results.getSuccessfulResults()
.map(r -> r.getSearchShardTarget().toString())
.collect(Collectors.joining(","));
logger.trace(
"[{}] Moving to next phase: [{}], based on results from: {} (cluster state version: {})",
currentPhase,
nextPhase.getName(),
resultsFrom,
clusterStateVersion
);
}
executePhase(nextPhase);
}
}
private void executePhase(SearchPhase phase) {
try {
phase.run();
} catch (RuntimeException e) {
if (logger.isDebugEnabled()) {
logger.debug(() -> format("Failed to execute [%s] while moving to [%s] phase", request, phase.getName()), e);
}
onPhaseFailure(phase.getName(), "", e);
}
}
private ShardSearchFailure[] buildShardFailures() {
AtomicArray<ShardSearchFailure> shardFailures = this.shardFailures.get();
if (shardFailures == null) {
return ShardSearchFailure.EMPTY_ARRAY;
}
List<ShardSearchFailure> entries = shardFailures.asList();
ShardSearchFailure[] failures = new ShardSearchFailure[entries.size()];
for (int i = 0; i < failures.length; i++) {
failures[i] = entries.get(i);
}
return failures;
}
protected final void onShardFailure(final int shardIndex, SearchShardTarget shard, final SearchShardIterator shardIt, Exception e) {
// we always add the shard failure for a specific shard instance
// we do make sure to clean it on a successful response from a shard
onShardFailure(shardIndex, shard, e);
final SearchShardTarget nextShard = shardIt.nextOrNull();
final boolean lastShard = nextShard == null;
logger.debug(() -> format("%s: Failed to execute [%s] lastShard [%s]", shard, request, lastShard), e);
if (lastShard) {
if (request.allowPartialSearchResults() == false) {
if (requestCancelled.compareAndSet(false, true)) {
try {
searchTransportService.cancelSearchTask(task, "partial results are not allowed and at least one shard has failed");
} catch (Exception cancelFailure) {
logger.debug("Failed to cancel search request", cancelFailure);
}
}
}
onShardGroupFailure(shardIndex, shard, e);
}
if (lastShard == false) {
logger.debug("Retrying shard [{}] with target [{}]", shard.getShardId(), nextShard);
performPhaseOnShard(shardIndex, shardIt, nextShard);
} else {
// count down outstanding shards, we're done with this shard as there's no more copies to try
finishOneShard();
}
}
private void finishOneShard() {
final int outstanding = outstandingShards.decrementAndGet();
assert outstanding >= 0 : "outstanding: " + outstanding;
if (outstanding == 0) {
onPhaseDone();
}
}
/**
* Executed once for every {@link ShardId} that failed on all available shard routing.
*
* @param shardIndex the shard index that failed
* @param shardTarget the last shard target for this failure
* @param exc the last failure reason
*/
protected void onShardGroupFailure(int shardIndex, SearchShardTarget shardTarget, Exception exc) {}
/**
* Executed once for every failed shard level request. This method is invoked before the next replica is tried for the given
* shard target.
* @param shardIndex the internal index for this shard. Each shard has an index / ordinal assigned that is used to reference
* it's results
* @param shardTarget the shard target for this failure
* @param e the failure reason
*/
void onShardFailure(final int shardIndex, SearchShardTarget shardTarget, Exception e) {
if (TransportActions.isShardNotAvailableException(e)) {
// Groups shard not available exceptions under a generic exception that returns a SERVICE_UNAVAILABLE(503)
// temporary error.
e = NoShardAvailableActionException.forOnShardFailureWrapper(e.getMessage());
}
// we don't aggregate shard on failures due to the internal cancellation,
// but do keep the header counts right
if ((requestCancelled.get() && ExceptionsHelper.isTaskCancelledException(e)) == false) {
AtomicArray<ShardSearchFailure> shardFailures = this.shardFailures.get();
// lazily create shard failures, so we can early build the empty shard failure list in most cases (no failures)
if (shardFailures == null) { // this is double checked locking but it's fine since SetOnce uses a volatile read internally
synchronized (this.shardFailures) {
shardFailures = this.shardFailures.get(); // read again otherwise somebody else has created it?
if (shardFailures == null) { // still null so we are the first and create a new instance
shardFailures = new AtomicArray<>(getNumShards());
this.shardFailures.set(shardFailures);
}
}
}
ShardSearchFailure failure = shardFailures.get(shardIndex);
if (failure == null) {
shardFailures.set(shardIndex, new ShardSearchFailure(e, shardTarget));
} else {
// the failure is already present, try and not override it with an exception that is less meaningless
// for example, getting illegal shard state
if (TransportActions.isReadOverrideException(e) && (e instanceof SearchContextMissingException == false)) {
shardFailures.set(shardIndex, new ShardSearchFailure(e, shardTarget));
}
}
if (results.hasResult(shardIndex)) {
assert failure == null : "shard failed before but shouldn't: " + failure;
successfulOps.decrementAndGet(); // if this shard was successful before (initial phase) we have to adjust the counter
}
}
}
/**
* Executed once for every successful shard level request.
* @param result the result returned form the shard
*/
protected void onShardResult(Result result) {
assert result.getShardIndex() != -1 : "shard index is not set";
assert result.getSearchShardTarget() != null : "search shard target must not be null";
hasShardResponse.set(true);
if (logger.isTraceEnabled()) {
logger.trace("got first-phase result from {}", result != null ? result.getSearchShardTarget() : null);
}
// clean a previous error on this shard group (note, this code will be serialized on the same shardIndex value level
// so it's ok concurrency wise to miss potentially the shard failures being created because of another failure
// in the #addShardFailure, because by definition, it will happen on *another* shardIndex
AtomicArray<ShardSearchFailure> shardFailures = this.shardFailures.get();
if (shardFailures != null) {
shardFailures.set(result.getShardIndex(), null);
}
results.consumeResult(result, () -> {
successfulOps.incrementAndGet();
finishOneShard();
});
}
/**
* Returns the total number of shards to the current search across all indices
*/
public final int getNumShards() {
return results.getNumShards();
}
/**
* Returns a logger for this context to prevent each individual phase to create their own logger.
*/
public final Logger getLogger() {
return logger;
}
/**
* Returns the currently executing search task
*/
public final SearchTask getTask() {
return task;
}
/**
* Returns the currently executing search request
*/
public final SearchRequest getRequest() {
return request;
}
/**
* Returns the targeted {@link OriginalIndices} for the provided {@code shardIndex}.
*/
public OriginalIndices getOriginalIndices(int shardIndex) {
return shardIterators[shardIndex].getOriginalIndices();
}
/**
* Checks if the given context id is part of the point in time of this search (if exists).
* We should not release search contexts that belong to the point in time during or after searches.
*/
public boolean isPartOfPointInTime(ShardSearchContextId contextId) {
final PointInTimeBuilder pointInTimeBuilder = request.pointInTimeBuilder();
if (pointInTimeBuilder != null) {
return request.pointInTimeBuilder().getSearchContextId(namedWriteableRegistry).contains(contextId);
} else {
return false;
}
}
private SearchResponse buildSearchResponse(
SearchResponseSections internalSearchResponse,
ShardSearchFailure[] failures,
String scrollId,
BytesReference searchContextId
) {
int numSuccess = successfulOps.get();
int numFailures = failures.length;
assert numSuccess + numFailures == getNumShards()
: "numSuccess(" + numSuccess + ") + numFailures(" + numFailures + ") != totalShards(" + getNumShards() + ")";
return new SearchResponse(
internalSearchResponse,
scrollId,
getNumShards(),
numSuccess,
skippedCount,
buildTookInMillis(),
failures,
clusters,
searchContextId
);
}
/**
* Builds and sends the final search response back to the user.
*
* @param internalSearchResponse the internal search response
* @param queryResults the results of the query phase
*/
public void sendSearchResponse(SearchResponseSections internalSearchResponse, AtomicArray<SearchPhaseResult> queryResults) {
ShardSearchFailure[] failures = buildShardFailures();
Boolean allowPartialResults = request.allowPartialSearchResults();
assert allowPartialResults != null : "SearchRequest missing setting for allowPartialSearchResults";
if (allowPartialResults == false && failures.length > 0) {
raisePhaseFailure(new SearchPhaseExecutionException("", "Shard failures", null, failures));
} else {
ActionListener.respondAndRelease(
listener,
buildSearchResponse(
internalSearchResponse,
failures,
request.scroll() != null ? TransportSearchHelper.buildScrollId(queryResults) : null,
buildSearchContextId(failures)
)
);
}
}
protected BytesReference buildSearchContextId(ShardSearchFailure[] failures) {
SearchSourceBuilder source = request.source();
// only (re-)build a search context id if we are running a long-lived point-in-time request
if (source != null && source.pointInTimeBuilder() != null && source.pointInTimeBuilder().singleSession() == false) {
if (SearchService.PIT_RELOCATION_FEATURE_FLAG.isEnabled()) {
// we want to change node ids in the PIT id if any shards and its PIT context have moved
return maybeReEncodeNodeIds(
source.pointInTimeBuilder(),
results.getAtomicArray().asList(),
namedWriteableRegistry,
mintransportVersion,
searchTransportService,
discoveryNodes.get(),
logger
);
} else {
return source.pointInTimeBuilder().getEncodedId();
}
} else {
return null;
}
}
static <Result extends SearchPhaseResult> BytesReference maybeReEncodeNodeIds(
PointInTimeBuilder originalPit,
List<Result> results,
NamedWriteableRegistry namedWriteableRegistry,
TransportVersion mintransportVersion,
SearchTransportService searchTransportService,
DiscoveryNodes nodes,
Logger logger
) {
SearchContextId original = originalPit.getSearchContextId(namedWriteableRegistry);
// only create the following two collections if we detect an id change
Map<ShardId, SearchContextIdForNode> updatedShardMap = null;
Collection<SearchContextIdForNode> contextsToClose = null;
logger.debug("checking search result shards to detect PIT node changes");
for (Result result : results) {
SearchShardTarget searchShardTarget = result.getSearchShardTarget();
ShardId shardId = searchShardTarget.getShardId();
SearchContextIdForNode originalShard = original.shards().get(shardId);
if (originalShard != null && originalShard.getSearchContextId() != null && originalShard.getSearchContextId().isRetryable()) {
// check if the node is different, if so we need to re-encode the PIT
String originalNode = originalShard.getNode();
if (originalNode != null && originalNode.equals(searchShardTarget.getNodeId()) == false) {
// the target node for this shard entry in the PIT has changed, we need to update it
if (updatedShardMap == null) {
// initialize the map with entries from old map to keep ids for shards that have not responded in this results
updatedShardMap = new HashMap<>(original.shards());
contextsToClose = new ArrayList<>();
}
SearchContextIdForNode updatedId = new SearchContextIdForNode(
searchShardTarget.getClusterAlias(),
searchShardTarget.getNodeId(),
result.getContextId()
);
logger.debug("changing node for PIT shard id from [{}] to [{}]", originalShard, updatedId);
updatedShardMap.put(shardId, updatedId);
contextsToClose.add(original.shards().get(shardId));
}
}
}
if (updatedShardMap != null) {
// we free all old contexts that have moved, just in case we have re-tried them elsewhere
// but they still exist in the old location
closeContexts(nodes, searchTransportService, contextsToClose, new ActionListener<Integer>() {
@Override
public void onResponse(Integer integer) {
// ignore
}
@Override
public void onFailure(Exception e) {
logger.trace("Failure while freeing old point in time contexts", e);
}
});
return SearchContextId.encode(updatedShardMap, original.aliasFilter(), mintransportVersion, ShardSearchFailure.EMPTY_ARRAY);
} else {
return originalPit.getEncodedId();
}
}
/**
* This method will communicate a fatal phase failure back to the user. In contrast to a shard failure
* will this method immediately fail the search request and return the failure to the issuer of the request
* @param phase the phase that failed
* @param msg an optional message
* @param cause the cause of the phase failure
*/
public void onPhaseFailure(String phase, String msg, Throwable cause) {
raisePhaseFailure(new SearchPhaseExecutionException(phase, msg, cause, buildShardFailures()));
}
/**
* This method should be called if a search phase failed to ensure all relevant reader contexts are released.
* This method will also notify the listener and sends back a failure to the user.
*
* @param exception the exception explaining or causing the phase failure
*/
private void raisePhaseFailure(SearchPhaseExecutionException exception) {
results.getSuccessfulResults().forEach((entry) -> {
// Do not release search contexts that are part of the point in time
if (entry.getContextId() != null && isPartOfPointInTime(entry.getContextId()) == false) {
try {
SearchShardTarget searchShardTarget = entry.getSearchShardTarget();
Transport.Connection connection = getConnection(searchShardTarget.getClusterAlias(), searchShardTarget.getNodeId());
sendReleaseSearchContext(entry.getContextId(), connection);
} catch (Exception inner) {
inner.addSuppressed(exception);
logger.trace("failed to release context", inner);
}
}
});
listener.onFailure(exception);
}
/**
* Releases a search context with the given context ID on the node the given connection is connected to.
* @see org.elasticsearch.search.query.QuerySearchResult#getContextId()
* @see org.elasticsearch.search.fetch.FetchSearchResult#getContextId()
*
*/
void sendReleaseSearchContext(ShardSearchContextId contextId, Transport.Connection connection) {
assert isPartOfPointInTime(contextId) == false : "Must not release point in time context [" + contextId + "]";
if (connection != null) {
searchTransportService.sendFreeContext(connection, contextId, ActionListener.noop());
}
}
/**
* Executed once all shard results have been received and processed
* @see #onShardFailure(int, SearchShardTarget, Exception)
* @see #onShardResult(SearchPhaseResult)
*/
private void onPhaseDone() { // as a tribute to @kimchy aka. finishHim()
searchResponseMetrics.recordSearchPhaseDuration(getName(), System.nanoTime() - phaseStartTimeInNanos, searchRequestAttributes);
executeNextPhase(getName(), this::getNextPhase);
}
/**
* Returns a connection to the node if connected otherwise and {@link org.elasticsearch.transport.ConnectTransportException} will be
* thrown.
*/
public final Transport.Connection getConnection(String clusterAlias, String nodeId) {
return nodeIdToConnection.apply(clusterAlias, nodeId);
}
/**
* Returns the {@link SearchTransportService} to send shard request to other nodes
*/
public SearchTransportService getSearchTransport() {
return searchTransportService;
}
/**
* Returns the {@link SearchResponseMetrics} to record search phase timings
*/
public SearchResponseMetrics getSearchResponseMetrics() {
return searchResponseMetrics;
}
/**
* Returns search request attributes used to record attributes for search phase timings in an immutable map.
*/
public Map<String, Object> getSearchRequestAttributes() {
return Collections.unmodifiableMap(searchRequestAttributes);
}
public final void execute(Runnable command) {
executor.execute(command);
}
/**
* Builds an request for the initial search phase.
*
* @param shardIt the target {@link SearchShardIterator}
* @param shardIndex the index of the shard that is used in the coordinator node to
* tiebreak results with identical sort values
*/
protected final ShardSearchRequest buildShardSearchRequest(SearchShardIterator shardIt, int shardIndex) {
AliasFilter filter = aliasFilter.get(shardIt.shardId().getIndex().getUUID());
assert filter != null;
float indexBoost = concreteIndexBoosts.getOrDefault(shardIt.shardId().getIndex().getUUID(), DEFAULT_INDEX_BOOST);
ShardSearchRequest shardRequest = new ShardSearchRequest(
shardIt.getOriginalIndices(),
request,
shardIt.shardId(),
shardIndex,
getNumShards(),
filter,
indexBoost,
timeProvider.absoluteStartMillis(),
shardIt.getClusterAlias(),
shardIt.getSearchContextId(),
shardIt.getSearchContextKeepAlive(),
shardIt.getSplitShardCountSummary()
);
// if we already received a search result we can inform the shard that it
// can return a null response if the request rewrites to match none rather
// than creating an empty response in the search thread pool.
// Note that, we have to disable this shortcut for queries that create a context (scroll and search context).
shardRequest.canReturnNullResponseIfMatchNoDocs(hasShardResponse.get() && shardRequest.scroll() == null);
return shardRequest;
}
/**
* Returns the next phase based on the results of the initial search phase
*/
protected abstract SearchPhase getNextPhase();
private static final | AbstractSearchAsyncAction |
java | apache__flink | flink-table/flink-table-planner/src/main/java/org/apache/flink/table/planner/operations/converters/SqlNodeConverters.java | {
"start": 7529,
"end": 8735
} | class ____
SqlNodeConverter sqlKindConverter = SQLKIND_CONVERTERS.get(validatedSqlNode.getKind());
if (sqlKindConverter != null) {
return Optional.of(sqlKindConverter.convertSqlNode(validatedSqlNode, context));
} else {
return Optional.empty();
}
}
private static void register(SqlNodeConverter<?> converter) {
// register by SqlKind if it is defined
if (converter.supportedSqlKinds().isPresent()) {
for (SqlKind sqlKind : converter.supportedSqlKinds().get()) {
if (SQLKIND_CONVERTERS.containsKey(sqlKind)) {
throw new IllegalArgumentException(
String.format(
"Failed to register converter for '%s', because there is a "
+ "registered converter for the SqlKind '%s'",
converter.getClass().getCanonicalName(), sqlKind));
} else {
SQLKIND_CONVERTERS.put(sqlKind, converter);
}
}
return;
}
// extract the parameter type of the converter | converters |
java | apache__logging-log4j2 | log4j-api/src/main/java/org/apache/logging/log4j/spi/AbstractLogger.java | {
"start": 22352,
"end": 23039
} | class ____ of the <b>caller</b>.
* @param format The format String for the parameters.
* @param paramSuppliers The parameters to the method.
* @since 2.6
*/
@Deprecated
protected EntryMessage enter(final String fqcn, final String format, final MessageSupplier... paramSuppliers) {
EntryMessage entryMsg = null;
if (isEnabled(Level.TRACE, ENTRY_MARKER, (Object) null, null)) {
logMessageSafely(fqcn, Level.TRACE, ENTRY_MARKER, entryMsg = entryMsg(format, paramSuppliers), null);
}
return entryMsg;
}
/**
* Logs entry to a method with location information.
*
* @param fqcn The fully qualified | name |
java | apache__kafka | metadata/src/test/java/org/apache/kafka/controller/QuorumControllerTest.java | {
"start": 9182,
"end": 82404
} | class ____ {
private static final Logger log = LoggerFactory.getLogger(QuorumControllerTest.class);
static final BootstrapMetadata SIMPLE_BOOTSTRAP = BootstrapMetadata.
fromVersion(MetadataVersion.IBP_3_7_IV0, "test-provided bootstrap");
/**
* Test setting some configuration values and reading them back.
*/
@Test
public void testConfigurationOperations() throws Throwable {
try (
MockRaftClientTestEnv clientEnv = new MockRaftClientTestEnv.Builder(1).
build();
QuorumControllerTestEnv controlEnv = new QuorumControllerTestEnv.Builder(clientEnv).
build()
) {
controlEnv.activeController().registerBroker(ANONYMOUS_CONTEXT,
new BrokerRegistrationRequestData().
setFeatures(brokerFeaturesPlusFeatureVersions(MetadataVersion.MINIMUM_VERSION, MetadataVersion.latestTesting(),
Map.of(EligibleLeaderReplicasVersion.FEATURE_NAME, EligibleLeaderReplicasVersion.ELRV_1.featureLevel()))).
setBrokerId(0).
setLogDirs(List.of(Uuid.fromString("iiaQjkRPQcuMULNII0MUeA"))).
setClusterId(clientEnv.clusterId())).get();
testConfigurationOperations(controlEnv.activeController());
testToImages(clientEnv.allRecords());
}
}
private void testConfigurationOperations(QuorumController controller) throws Throwable {
assertEquals(Map.of(BROKER0, ApiError.NONE),
controller.incrementalAlterConfigs(ANONYMOUS_CONTEXT, Map.of(
BROKER0, Map.of("baz", entry(SET, "123"))), true).get());
assertEquals(Map.of(BROKER0,
new ResultOrError<>(Map.of())),
controller.describeConfigs(ANONYMOUS_CONTEXT, Map.of(
BROKER0, List.of())).get());
assertEquals(Map.of(BROKER0, ApiError.NONE),
controller.incrementalAlterConfigs(ANONYMOUS_CONTEXT, Map.of(
BROKER0, Map.of("baz", entry(SET, "123"))), false).get());
assertEquals(Map.of(BROKER0, new ResultOrError<>(Map.of("baz", "123"))),
controller.describeConfigs(ANONYMOUS_CONTEXT, Map.of(
BROKER0, List.of())).get());
}
/**
* Test that an incrementalAlterConfigs operation doesn't complete until the records
* can be written to the metadata log.
*/
@Test
public void testDelayedConfigurationOperations() throws Throwable {
try (
MockRaftClientTestEnv clientEnv = new MockRaftClientTestEnv.Builder(1).
build();
QuorumControllerTestEnv controlEnv = new QuorumControllerTestEnv.Builder(clientEnv).
build()
) {
controlEnv.activeController().registerBroker(ANONYMOUS_CONTEXT,
new BrokerRegistrationRequestData().
setFeatures(brokerFeaturesPlusFeatureVersions(MetadataVersion.MINIMUM_VERSION, MetadataVersion.latestTesting(),
Map.of(EligibleLeaderReplicasVersion.FEATURE_NAME, EligibleLeaderReplicasVersion.ELRV_1.featureLevel()))).
setBrokerId(0).
setLogDirs(List.of(Uuid.fromString("sTbzRAMnTpahIyIPNjiLhw"))).
setClusterId(clientEnv.clusterId())).get();
testDelayedConfigurationOperations(clientEnv, controlEnv.activeController());
testToImages(clientEnv.allRecords());
}
}
private void testDelayedConfigurationOperations(
MockRaftClientTestEnv clientEnv,
QuorumController controller
) throws Throwable {
clientEnv.raftClients().forEach(m -> m.setMaxReadOffset(1L));
CompletableFuture<Map<ConfigResource, ApiError>> future1 =
controller.incrementalAlterConfigs(ANONYMOUS_CONTEXT, Map.of(
BROKER0, Map.of("baz", entry(SET, "123"))), false);
assertFalse(future1.isDone());
assertEquals(Map.of(BROKER0,
new ResultOrError<>(Map.of())),
controller.describeConfigs(ANONYMOUS_CONTEXT, Map.of(
BROKER0, List.of())).get());
clientEnv.raftClients().forEach(m -> m.setMaxReadOffset(8L));
assertEquals(Map.of(BROKER0, ApiError.NONE), future1.get());
}
@Test
public void testFenceMultipleBrokers() throws Throwable {
List<Integer> allBrokers = List.of(1, 2, 3, 4, 5);
List<Integer> brokersToKeepUnfenced = List.of(1);
List<Integer> brokersToFence = List.of(2, 3, 4, 5);
short replicationFactor = (short) allBrokers.size();
short numberOfPartitions = (short) allBrokers.size();
long sessionTimeoutMillis = 1000;
try (
MockRaftClientTestEnv clientEnv = new MockRaftClientTestEnv.Builder(1).
build();
QuorumControllerTestEnv controlEnv = new QuorumControllerTestEnv.Builder(clientEnv).
setSessionTimeoutMillis(OptionalLong.of(sessionTimeoutMillis)).
setBootstrapMetadata(SIMPLE_BOOTSTRAP).
build()
) {
ListenerCollection listeners = new ListenerCollection();
listeners.add(new Listener().setName("PLAINTEXT").setHost("localhost").setPort(9092));
QuorumController active = controlEnv.activeController();
Map<Integer, Long> brokerEpochs = new HashMap<>();
for (Integer brokerId : allBrokers) {
CompletableFuture<BrokerRegistrationReply> reply = active.registerBroker(
ANONYMOUS_CONTEXT,
new BrokerRegistrationRequestData().
setBrokerId(brokerId).
setClusterId(active.clusterId()).
setFeatures(brokerFeatures(MetadataVersion.MINIMUM_VERSION, MetadataVersion.latestTesting())).
setIncarnationId(Uuid.randomUuid()).
setListeners(listeners));
brokerEpochs.put(brokerId, reply.get().epoch());
}
// Brokers are only registered and should still be fenced
allBrokers.forEach(brokerId ->
assertFalse(active.clusterControl().isUnfenced(brokerId), "Broker " + brokerId + " should have been fenced")
);
// Unfence all brokers and create a topic foo
sendBrokerHeartbeatToUnfenceBrokers(active, allBrokers, brokerEpochs);
CreateTopicsRequestData createTopicsRequestData = new CreateTopicsRequestData().setTopics(
new CreatableTopicCollection(Set.of(
new CreatableTopic().setName("foo").setNumPartitions(numberOfPartitions).
setReplicationFactor(replicationFactor)).iterator()));
CreateTopicsResponseData createTopicsResponseData = active.createTopics(
ANONYMOUS_CONTEXT, createTopicsRequestData,
Set.of("foo")).get();
assertEquals(Errors.NONE, Errors.forCode(createTopicsResponseData.topics().find("foo").errorCode()));
Uuid topicIdFoo = createTopicsResponseData.topics().find("foo").topicId();
// Fence some of the brokers
TestUtils.waitForCondition(() -> {
sendBrokerHeartbeatToUnfenceBrokers(active, brokersToKeepUnfenced, brokerEpochs);
for (Integer brokerId : brokersToFence) {
if (active.clusterControl().isUnfenced(brokerId)) {
return false;
}
}
return true;
}, sessionTimeoutMillis * 3,
"Fencing of brokers did not process within expected time"
);
// Send another heartbeat to the brokers we want to keep alive
sendBrokerHeartbeatToUnfenceBrokers(active, brokersToKeepUnfenced, brokerEpochs);
// At this point only the brokers we want fenced should be fenced.
brokersToKeepUnfenced.forEach(brokerId ->
assertTrue(active.clusterControl().isUnfenced(brokerId), "Broker " + brokerId + " should have been unfenced")
);
brokersToFence.forEach(brokerId ->
assertFalse(active.clusterControl().isUnfenced(brokerId), "Broker " + brokerId + " should have been fenced")
);
// Verify the isr and leaders for the topic partition
int[] expectedIsr = {1};
int[] isrFoo = active.replicationControl().getPartition(topicIdFoo, 0).isr;
assertArrayEquals(isrFoo, expectedIsr, "The ISR for topic foo was " + Arrays.toString(isrFoo) +
". It is expected to be " + Arrays.toString(expectedIsr));
int fooLeader = active.replicationControl().getPartition(topicIdFoo, 0).leader;
assertEquals(expectedIsr[0], fooLeader);
// Check that there are imbalaned partitions
assertTrue(active.replicationControl().arePartitionLeadersImbalanced());
testToImages(clientEnv.allRecords());
}
}
@Test
public void testElrEnabledByDefault() throws Throwable {
long sessionTimeoutMillis = 500;
try (
MockRaftClientTestEnv clientEnv = new MockRaftClientTestEnv.Builder(1).
build();
QuorumControllerTestEnv controlEnv = new QuorumControllerTestEnv.Builder(clientEnv).
setSessionTimeoutMillis(OptionalLong.of(sessionTimeoutMillis)).
setBootstrapMetadata(BootstrapMetadata.fromRecords(
List.of(
new ApiMessageAndVersion(new FeatureLevelRecord().
setName(MetadataVersion.FEATURE_NAME).
setFeatureLevel(MetadataVersion.IBP_4_0_IV1.featureLevel()), (short) 0),
new ApiMessageAndVersion(new FeatureLevelRecord().
setName(EligibleLeaderReplicasVersion.FEATURE_NAME).
setFeatureLevel(EligibleLeaderReplicasVersion.ELRV_1.featureLevel()), (short) 0)
),
"test-provided bootstrap ELR enabled"
)).
build()
) {
controlEnv.activeController(true);
assertTrue(controlEnv.activeController().configurationControl().clusterConfig().containsKey(TopicConfig.MIN_IN_SYNC_REPLICAS_CONFIG));
}
}
@Test
public void testUncleanShutdownBrokerElrEnabled() throws Throwable {
List<Integer> allBrokers = List.of(1, 2, 3);
Map<Integer, Uuid> brokerLogDirs = allBrokers.stream().collect(
Collectors.toMap(identity(), brokerId -> Uuid.randomUuid())
);
short replicationFactor = (short) allBrokers.size();
long sessionTimeoutMillis = 500;
try (
MockRaftClientTestEnv clientEnv = new MockRaftClientTestEnv.Builder(1).
build();
QuorumControllerTestEnv controlEnv = new QuorumControllerTestEnv.Builder(clientEnv).
setSessionTimeoutMillis(OptionalLong.of(sessionTimeoutMillis)).
setBootstrapMetadata(BootstrapMetadata.fromVersion(MetadataVersion.IBP_4_0_IV1, "test-provided bootstrap ELR enabled")).
build()
) {
ListenerCollection listeners = new ListenerCollection();
listeners.add(new Listener().setName("PLAINTEXT").setHost("localhost").setPort(9092));
QuorumController active = controlEnv.activeController();
Map<Integer, Long> brokerEpochs = new HashMap<>();
BrokerRegistrationRequestData.FeatureCollection features =
brokerFeaturesPlusFeatureVersions(MetadataVersion.MINIMUM_VERSION, MetadataVersion.IBP_4_0_IV1,
Map.of(EligibleLeaderReplicasVersion.FEATURE_NAME, EligibleLeaderReplicasVersion.ELRV_1.featureLevel()));
for (Integer brokerId : allBrokers) {
CompletableFuture<BrokerRegistrationReply> reply = active.registerBroker(
anonymousContextFor(ApiKeys.BROKER_REGISTRATION),
new BrokerRegistrationRequestData().
setBrokerId(brokerId).
setClusterId(active.clusterId()).
setFeatures(features).
setIncarnationId(Uuid.randomUuid()).
setLogDirs(List.of(brokerLogDirs.get(brokerId))).
setListeners(listeners));
brokerEpochs.put(brokerId, reply.get().epoch());
}
// Brokers are only registered and should still be fenced
allBrokers.forEach(brokerId ->
assertFalse(active.clusterControl().isUnfenced(brokerId), "Broker " + brokerId + " should have been fenced")
);
// Unfence all brokers and create a topic foo
sendBrokerHeartbeatToUnfenceBrokers(active, allBrokers, brokerEpochs);
CreateTopicsRequestData createTopicsRequestData = new CreateTopicsRequestData().setTopics(
new CreatableTopicCollection(Set.of(
new CreatableTopic().setName("foo").setNumPartitions(1).
setReplicationFactor(replicationFactor)).iterator()));
CreateTopicsResponseData createTopicsResponseData = active.createTopics(
ANONYMOUS_CONTEXT, createTopicsRequestData,
Set.of("foo")).get();
assertEquals(Errors.NONE, Errors.forCode(createTopicsResponseData.topics().find("foo").errorCode()));
Uuid topicIdFoo = createTopicsResponseData.topics().find("foo").topicId();
ConfigRecord configRecord = new ConfigRecord()
.setResourceType(ConfigResource.Type.TOPIC.id())
.setResourceName("foo")
.setName(org.apache.kafka.common.config.TopicConfig.MIN_IN_SYNC_REPLICAS_CONFIG)
.setValue("2");
RecordTestUtils.replayAll(active.configurationControl(), List.of(new ApiMessageAndVersion(configRecord, (short) 0)));
// Fence all the brokers
TestUtils.waitForCondition(() -> {
for (Integer brokerId : allBrokers) {
if (active.clusterControl().isUnfenced(brokerId)) {
return false;
}
}
return true;
}, sessionTimeoutMillis * 30,
"Fencing of brokers did not process within expected time"
);
// Verify the isr and elr for the topic partition
PartitionRegistration partition = active.replicationControl().getPartition(topicIdFoo, 0);
assertEquals(1, partition.lastKnownElr.length, partition.toString());
int[] lastKnownElr = partition.lastKnownElr;
assertEquals(0, partition.isr.length, partition.toString());
assertEquals(NO_LEADER, partition.leader, partition.toString());
// The ELR set is not determined.
assertEquals(2, partition.elr.length, partition.toString());
int brokerToUncleanShutdown, brokerToBeTheLeader;
// lastKnownElr stores the last known leader.
brokerToUncleanShutdown = lastKnownElr[0];
if (lastKnownElr[0] == partition.elr[0]) {
brokerToBeTheLeader = partition.elr[1];
} else {
brokerToBeTheLeader = partition.elr[0];
}
// Unclean shutdown should remove brokerToUncleanShutdown from the ELR members, but it should still be in
// the lastKnownElr.
CompletableFuture<BrokerRegistrationReply> reply = active.registerBroker(
anonymousContextFor(ApiKeys.BROKER_REGISTRATION),
new BrokerRegistrationRequestData().
setBrokerId(brokerToUncleanShutdown).
setClusterId(active.clusterId()).
setFeatures(features).
setIncarnationId(Uuid.randomUuid()).
setLogDirs(List.of(brokerLogDirs.get(brokerToUncleanShutdown))).
setListeners(listeners));
brokerEpochs.put(brokerToUncleanShutdown, reply.get().epoch());
partition = active.replicationControl().getPartition(topicIdFoo, 0);
assertArrayEquals(new int[]{brokerToBeTheLeader}, partition.elr, partition.toString());
assertArrayEquals(lastKnownElr, partition.lastKnownElr, partition.toString());
// Unclean shutdown should not remove the last known ELR members.
CompletableFuture<BrokerRegistrationReply> replyLeader = active.registerBroker(
anonymousContextFor(ApiKeys.BROKER_REGISTRATION),
new BrokerRegistrationRequestData().
setBrokerId(brokerToBeTheLeader).
setClusterId(active.clusterId()).
setFeatures(features).
setIncarnationId(Uuid.randomUuid()).
setPreviousBrokerEpoch(brokerEpochs.get(brokerToBeTheLeader)).
setLogDirs(List.of(brokerLogDirs.get(brokerToBeTheLeader))).
setListeners(listeners));
brokerEpochs.put(brokerToBeTheLeader, replyLeader.get().epoch());
partition = active.replicationControl().getPartition(topicIdFoo, 0);
int[] expectedIsr = {brokerToBeTheLeader};
assertArrayEquals(expectedIsr, partition.elr, "The ELR for topic partition foo-0 was " + Arrays.toString(partition.elr) +
". It is expected to be " + Arrays.toString(expectedIsr));
assertArrayEquals(lastKnownElr, partition.lastKnownElr, "The last known ELR for topic partition foo-0 was " + Arrays.toString(partition.lastKnownElr) +
". It is expected to be " + Arrays.toString(lastKnownElr));
// Unfence the last one in the ELR, it should be elected.
sendBrokerHeartbeatToUnfenceBrokers(active, List.of(brokerToBeTheLeader), brokerEpochs);
TestUtils.waitForCondition(() -> active.clusterControl().isUnfenced(brokerToBeTheLeader), sessionTimeoutMillis * 3,
"Broker should be unfenced."
);
partition = active.replicationControl().getPartition(topicIdFoo, 0);
assertArrayEquals(new int[]{brokerToBeTheLeader}, partition.isr, partition.toString());
assertEquals(0, partition.elr.length, partition.toString());
assertEquals(0, partition.lastKnownElr.length, partition.toString());
assertEquals(brokerToBeTheLeader, partition.leader, partition.toString());
}
}
@Test
public void testUncleanShutdownElrDisabled() throws Exception {
List<Integer> allBrokers = List.of(1, 2, 3);
short replicationFactor = (short) allBrokers.size();
long sessionTimeoutMillis = 500;
try (
MockRaftClientTestEnv clientEnv = new MockRaftClientTestEnv.Builder(1).
build();
QuorumControllerTestEnv controlEnv = new QuorumControllerTestEnv.Builder(clientEnv)
.setControllerBuilderInitializer(controllerBuilder ->
controllerBuilder.setFenceStaleBrokerIntervalNs(TimeUnit.SECONDS.toNanos(15)))
.setSessionTimeoutMillis(OptionalLong.of(sessionTimeoutMillis))
.setBootstrapMetadata(BootstrapMetadata.fromVersion(MetadataVersion.IBP_4_0_IV0, "test-provided bootstrap ELR not supported"))
.build()
) {
ListenerCollection listeners = new ListenerCollection();
listeners.add(new Listener().setName("PLAINTEXT").setHost("localhost").setPort(9092));
QuorumController active = controlEnv.activeController();
Map<Integer, Long> brokerEpochs = new HashMap<>();
BrokerRegistrationRequestData.FeatureCollection features =
brokerFeaturesPlusFeatureVersions(MetadataVersion.MINIMUM_VERSION, MetadataVersion.IBP_4_0_IV0,
Map.of(EligibleLeaderReplicasVersion.FEATURE_NAME, EligibleLeaderReplicasVersion.ELRV_0.featureLevel()));
for (Integer brokerId : allBrokers) {
CompletableFuture<BrokerRegistrationReply> reply = active.registerBroker(
anonymousContextFor(ApiKeys.BROKER_REGISTRATION),
new BrokerRegistrationRequestData().
setBrokerId(brokerId).
setClusterId(active.clusterId()).
setFeatures(features).
setIncarnationId(Uuid.randomUuid()).
setLogDirs(List.of(Uuid.randomUuid())).
setListeners(listeners));
brokerEpochs.put(brokerId, reply.get().epoch());
}
// Brokers are only registered and should still be fenced
allBrokers.forEach(brokerId ->
assertFalse(active.clusterControl().isUnfenced(brokerId), "Broker " + brokerId + " should have been fenced")
);
// Unfence all brokers and create a topic foo
sendBrokerHeartbeatToUnfenceBrokers(active, allBrokers, brokerEpochs);
CreateTopicsRequestData createTopicsRequestData = new CreateTopicsRequestData().setTopics(
new CreatableTopicCollection(Set.of(
new CreatableTopic().setName("foo").setNumPartitions(1).
setReplicationFactor(replicationFactor)).iterator()));
CreateTopicsResponseData createTopicsResponseData = active.createTopics(
ANONYMOUS_CONTEXT, createTopicsRequestData,
Set.of("foo")).get();
assertEquals(Errors.NONE, Errors.forCode(createTopicsResponseData.topics().find("foo").errorCode()));
Uuid topicIdFoo = createTopicsResponseData.topics().find("foo").topicId();
// wait for brokers to become inactive
active.time().sleep(sessionTimeoutMillis);
// unclean shutdown for each replica
for (int i = 0; i < (int) replicationFactor; i++) {
// Verify that ELR is disabled
PartitionRegistration partition = active.replicationControl().getPartition(topicIdFoo, 0);
assertEquals(0, partition.elr.length, partition.toString());
assertEquals(0, partition.lastKnownElr.length, partition.toString());
boolean lastStandingIsr = i == (replicationFactor - 1);
int prevLeader = partition.leader;
int prevLeaderEpoch = partition.leaderEpoch;
// Unclean shutdown should remove the broker from the ISR and reassign leadership
active.registerBroker(
anonymousContextFor(ApiKeys.BROKER_REGISTRATION),
new BrokerRegistrationRequestData().
setBrokerId(prevLeader).
setClusterId(active.clusterId()).
setFeatures(features).
setIncarnationId(Uuid.randomUuid()).
setLogDirs(List.of(Uuid.randomUuid())).
setListeners(listeners)).get();
partition = active.replicationControl().getPartition(topicIdFoo, 0);
// leader should always change, leader epoch should always be incremented
int currentLeader = partition.leader;
int currentLeaderEpoch = partition.leaderEpoch;
assertNotEquals(currentLeader, prevLeader);
assertNotEquals(currentLeaderEpoch, prevLeaderEpoch);
// if the broker is not the last standing ISR, it should be removed from the ISR
if (lastStandingIsr) {
assertArrayEquals(new int[]{prevLeader}, partition.isr);
assertEquals(NO_LEADER, currentLeader);
} else {
List<Integer> isr = Arrays.stream(partition.isr).boxed().toList();
assertFalse(isr.contains(prevLeader));
}
}
}
}
@Flaky("KAFKA-18981")
@Test
public void testMinIsrUpdateWithElr() throws Throwable {
List<Integer> allBrokers = List.of(1, 2, 3);
List<Integer> brokersToKeepUnfenced = List.of(1);
List<Integer> brokersToFence = List.of(2, 3);
short replicationFactor = (short) allBrokers.size();
long sessionTimeoutMillis = 300;
try (
MockRaftClientTestEnv clientEnv = new MockRaftClientTestEnv.Builder(1).build();
QuorumControllerTestEnv controlEnv = new QuorumControllerTestEnv.Builder(clientEnv).
setSessionTimeoutMillis(OptionalLong.of(sessionTimeoutMillis)).
setBootstrapMetadata(BootstrapMetadata.fromVersion(MetadataVersion.IBP_4_0_IV1, "test-provided bootstrap ELR enabled")).
build()
) {
ListenerCollection listeners = new ListenerCollection();
listeners.add(new Listener().setName("PLAINTEXT").setHost("localhost").setPort(9092));
QuorumController active = controlEnv.activeController();
Map<Integer, Long> brokerEpochs = new HashMap<>();
for (Integer brokerId : allBrokers) {
CompletableFuture<BrokerRegistrationReply> reply = active.registerBroker(
anonymousContextFor(ApiKeys.BROKER_REGISTRATION),
new BrokerRegistrationRequestData().
setBrokerId(brokerId).
setClusterId(active.clusterId()).
setFeatures(brokerFeaturesPlusFeatureVersions(MetadataVersion.MINIMUM_VERSION, MetadataVersion.latestTesting(),
Map.of(EligibleLeaderReplicasVersion.FEATURE_NAME, EligibleLeaderReplicasVersion.ELRV_1.featureLevel()))).
setIncarnationId(Uuid.randomUuid()).
setLogDirs(List.of(Uuid.randomUuid())).
setListeners(listeners));
brokerEpochs.put(brokerId, reply.get().epoch());
}
// Brokers are only registered and should still be fenced
allBrokers.forEach(brokerId -> {
assertFalse(active.clusterControl().isUnfenced(brokerId),
"Broker " + brokerId + " should have been fenced");
});
// Unfence all brokers and create a topic foo (min ISR 2)
sendBrokerHeartbeatToUnfenceBrokers(active, allBrokers, brokerEpochs);
CreateTopicsRequestData createTopicsRequestData = new CreateTopicsRequestData().setTopics(
new CreatableTopicCollection(List.of(
new CreatableTopic().setName("foo").setNumPartitions(1).
setReplicationFactor(replicationFactor),
new CreatableTopic().setName("bar").setNumPartitions(1).
setReplicationFactor(replicationFactor)
).iterator()));
CreateTopicsResponseData createTopicsResponseData = active.createTopics(
ANONYMOUS_CONTEXT, createTopicsRequestData,
Set.of("foo", "bar")).get();
assertEquals(Errors.NONE, Errors.forCode(createTopicsResponseData.topics().find("foo").errorCode()));
assertEquals(Errors.NONE, Errors.forCode(createTopicsResponseData.topics().find("bar").errorCode()));
Uuid topicIdFoo = createTopicsResponseData.topics().find("foo").topicId();
Uuid topicIdBar = createTopicsResponseData.topics().find("bar").topicId();
ConfigRecord configRecord = new ConfigRecord()
.setResourceType(BROKER.id())
.setResourceName("")
.setName(TopicConfig.MIN_IN_SYNC_REPLICAS_CONFIG)
.setValue("2");
RecordTestUtils.replayAll(active.configurationControl(), List.of(new ApiMessageAndVersion(configRecord, (short) 0)));
// Fence brokers
TestUtils.waitForCondition(() -> {
sendBrokerHeartbeatToUnfenceBrokers(active, brokersToKeepUnfenced, brokerEpochs);
for (Integer brokerId : brokersToFence) {
if (active.clusterControl().isUnfenced(brokerId)) {
return false;
}
}
return true;
}, sessionTimeoutMillis * 30,
"Fencing of brokers did not process within expected time"
);
// Send another heartbeat to the brokers we want to keep alive
sendBrokerHeartbeatToUnfenceBrokers(active, brokersToKeepUnfenced, brokerEpochs);
// At this point only the brokers we want to fence (broker 2, 3) should be fenced.
brokersToKeepUnfenced.forEach(brokerId -> {
assertTrue(active.clusterControl().isUnfenced(brokerId),
"Broker " + brokerId + " should have been unfenced");
});
brokersToFence.forEach(brokerId -> {
assertFalse(active.clusterControl().isUnfenced(brokerId),
"Broker " + brokerId + " should have been fenced");
});
sendBrokerHeartbeatToUnfenceBrokers(active, brokersToKeepUnfenced, brokerEpochs);
// Verify the isr and elr for the topic partition
PartitionRegistration partition = active.replicationControl().getPartition(topicIdFoo, 0);
assertArrayEquals(new int[]{1}, partition.isr, partition.toString());
// The ELR set is not determined but the size is 1.
assertEquals(1, partition.elr.length, partition.toString());
// First, decrease the min ISR config to 1. This should clear the ELR fields.
ControllerResult<Map<ConfigResource, ApiError>> result = active.configurationControl().incrementalAlterConfigs(toMap(
entry(new ConfigResource(TOPIC, "foo"), toMap(entry(TopicConfig.MIN_IN_SYNC_REPLICAS_CONFIG, entry(SET, "1"))))),
true);
assertEquals(2, result.records().size(), result.records().toString());
RecordTestUtils.replayAll(active.configurationControl(), List.of(result.records().get(0)));
RecordTestUtils.replayAll(active.replicationControl(), List.of(result.records().get(1)));
partition = active.replicationControl().getPartition(topicIdFoo, 0);
assertEquals(0, partition.elr.length, partition.toString());
assertArrayEquals(new int[]{1}, partition.isr, partition.toString());
// Second, let's try update config on cluster level with the other topic.
partition = active.replicationControl().getPartition(topicIdBar, 0);
assertArrayEquals(new int[]{1}, partition.isr, partition.toString());
assertEquals(1, partition.elr.length, partition.toString());
result = active.configurationControl().incrementalAlterConfigs(toMap(
entry(new ConfigResource(BROKER, ""), toMap(entry(TopicConfig.MIN_IN_SYNC_REPLICAS_CONFIG, entry(SET, "1"))))),
true);
assertEquals(2, result.records().size(), result.records().toString());
RecordTestUtils.replayAll(active.configurationControl(), List.of(result.records().get(0)));
RecordTestUtils.replayAll(active.replicationControl(), List.of(result.records().get(1)));
partition = active.replicationControl().getPartition(topicIdBar, 0);
assertEquals(0, partition.elr.length, partition.toString());
assertArrayEquals(new int[]{1}, partition.isr, partition.toString());
}
}
@Test
public void testBalancePartitionLeaders() throws Throwable {
List<Integer> allBrokers = List.of(1, 2, 3);
List<Integer> brokersToKeepUnfenced = List.of(1, 2);
List<Integer> brokersToFence = List.of(3);
short replicationFactor = (short) allBrokers.size();
short numberOfPartitions = (short) allBrokers.size();
long sessionTimeoutMillis = 2000;
long leaderImbalanceCheckIntervalNs = 1_000_000_000;
try (
MockRaftClientTestEnv clientEnv = new MockRaftClientTestEnv.Builder(1).
build();
QuorumControllerTestEnv controlEnv = new QuorumControllerTestEnv.Builder(clientEnv).
setSessionTimeoutMillis(OptionalLong.of(sessionTimeoutMillis)).
setLeaderImbalanceCheckIntervalNs(OptionalLong.of(leaderImbalanceCheckIntervalNs)).
setBootstrapMetadata(SIMPLE_BOOTSTRAP).
build()
) {
ListenerCollection listeners = new ListenerCollection();
listeners.add(new Listener().setName("PLAINTEXT").setHost("localhost").setPort(9092));
QuorumController active = controlEnv.activeController();
Map<Integer, Long> brokerEpochs = new HashMap<>();
for (Integer brokerId : allBrokers) {
CompletableFuture<BrokerRegistrationReply> reply = active.registerBroker(
ANONYMOUS_CONTEXT,
new BrokerRegistrationRequestData().
setBrokerId(brokerId).
setClusterId(active.clusterId()).
setFeatures(brokerFeatures(MetadataVersion.MINIMUM_VERSION, MetadataVersion.IBP_3_7_IV0)).
setIncarnationId(Uuid.randomUuid()).
setListeners(listeners));
brokerEpochs.put(brokerId, reply.get().epoch());
}
// Brokers are only registered and should still be fenced
allBrokers.forEach(brokerId ->
assertFalse(active.clusterControl().isUnfenced(brokerId), "Broker " + brokerId + " should have been fenced")
);
// Unfence all brokers and create a topic foo
sendBrokerHeartbeatToUnfenceBrokers(active, allBrokers, brokerEpochs);
CreateTopicsRequestData createTopicsRequestData = new CreateTopicsRequestData().setTopics(
new CreatableTopicCollection(Set.of(
new CreatableTopic().setName("foo").setNumPartitions(numberOfPartitions).
setReplicationFactor(replicationFactor)).iterator()));
CreateTopicsResponseData createTopicsResponseData = active.createTopics(
ANONYMOUS_CONTEXT, createTopicsRequestData, Set.of("foo")).get();
assertEquals(Errors.NONE, Errors.forCode(createTopicsResponseData.topics().find("foo").errorCode()));
Uuid topicIdFoo = createTopicsResponseData.topics().find("foo").topicId();
// Fence some of the brokers
TestUtils.waitForCondition(
() -> {
sendBrokerHeartbeatToUnfenceBrokers(active, brokersToKeepUnfenced, brokerEpochs);
for (Integer brokerId : brokersToFence) {
if (active.clusterControl().isUnfenced(brokerId)) {
return false;
}
}
return true;
},
sessionTimeoutMillis * 3,
"Fencing of brokers did not process within expected time"
);
// Send another heartbeat to the brokers we want to keep alive
sendBrokerHeartbeatToUnfenceBrokers(active, brokersToKeepUnfenced, brokerEpochs);
// At this point only the brokers we want fenced should be fenced.
brokersToKeepUnfenced.forEach(brokerId ->
assertTrue(active.clusterControl().isUnfenced(brokerId), "Broker " + brokerId + " should have been unfenced")
);
brokersToFence.forEach(brokerId ->
assertFalse(active.clusterControl().isUnfenced(brokerId), "Broker " + brokerId + " should have been fenced")
);
// Check that there are imbalanced partitions
assertTrue(active.replicationControl().arePartitionLeadersImbalanced());
// Re-register all fenced brokers
for (Integer brokerId : brokersToFence) {
CompletableFuture<BrokerRegistrationReply> reply = active.registerBroker(
ANONYMOUS_CONTEXT,
new BrokerRegistrationRequestData().
setBrokerId(brokerId).
setClusterId(active.clusterId()).
setFeatures(brokerFeatures(MetadataVersion.MINIMUM_VERSION, MetadataVersion.IBP_3_7_IV0)).
setIncarnationId(Uuid.randomUuid()).
setListeners(listeners));
brokerEpochs.put(brokerId, reply.get().epoch());
}
// Unfence all brokers
sendBrokerHeartbeatToUnfenceBrokers(active, allBrokers, brokerEpochs);
// Let the unfenced broker, 3, join the ISR partition 2
Set<TopicIdPartition> imbalancedPartitions = new HashSet<>(active.replicationControl().imbalancedPartitions());
assertEquals(1, imbalancedPartitions.size());
TopicIdPartition impalancedTp = imbalancedPartitions.iterator().next();
int imbalancedPartitionId = impalancedTp.partitionId();
PartitionRegistration partitionRegistration = active.replicationControl().getPartition(topicIdFoo, imbalancedPartitionId);
AlterPartitionRequestData.PartitionData partitionData = new AlterPartitionRequestData.PartitionData()
.setPartitionIndex(imbalancedPartitionId)
.setLeaderEpoch(partitionRegistration.leaderEpoch)
.setPartitionEpoch(partitionRegistration.partitionEpoch)
.setNewIsrWithEpochs(AlterPartitionRequest.newIsrToSimpleNewIsrWithBrokerEpochs(List.of(1, 2, 3)));
AlterPartitionRequestData.TopicData topicData = new AlterPartitionRequestData.TopicData()
.setTopicId(impalancedTp.topicId());
topicData.partitions().add(partitionData);
AlterPartitionRequestData alterPartitionRequest = new AlterPartitionRequestData()
.setBrokerId(partitionRegistration.leader)
.setBrokerEpoch(brokerEpochs.get(partitionRegistration.leader));
alterPartitionRequest.topics().add(topicData);
active.alterPartition(ANONYMOUS_CONTEXT, new AlterPartitionRequest
.Builder(alterPartitionRequest).build(ApiKeys.ALTER_PARTITION.oldestVersion()).data()).get();
AtomicLong lastHeartbeatMs = new AtomicLong(getMonotonicMs(active.time()));
sendBrokerHeartbeatToUnfenceBrokers(active, allBrokers, brokerEpochs);
// Check that partitions are balanced
TestUtils.waitForCondition(
() -> {
long currentMonotonicMs = getMonotonicMs(active.time());
if (currentMonotonicMs > lastHeartbeatMs.get() + (sessionTimeoutMillis / 2)) {
lastHeartbeatMs.set(currentMonotonicMs);
sendBrokerHeartbeatToUnfenceBrokers(active, allBrokers, brokerEpochs);
}
return !active.replicationControl().arePartitionLeadersImbalanced();
},
TimeUnit.MILLISECONDS.convert(leaderImbalanceCheckIntervalNs * 10, TimeUnit.NANOSECONDS),
"Leaders were not balanced after unfencing all of the brokers"
);
testToImages(clientEnv.allRecords());
}
}
private static long getMonotonicMs(Time time) {
return TimeUnit.NANOSECONDS.toMillis(time.nanoseconds());
}
@Test
public void testNoOpRecordWriteAfterTimeout() throws Throwable {
long maxIdleIntervalNs = TimeUnit.MICROSECONDS.toNanos(100);
long maxReplicationDelayMs = 1_000;
try (
MockRaftClientTestEnv clientEnv = new MockRaftClientTestEnv.Builder(3).
build();
QuorumControllerTestEnv controlEnv = new QuorumControllerTestEnv.Builder(clientEnv).
setControllerBuilderInitializer(controllerBuilder ->
controllerBuilder.setMaxIdleIntervalNs(OptionalLong.of(maxIdleIntervalNs))
).
build()
) {
ListenerCollection listeners = new ListenerCollection();
listeners.add(new Listener().setName("PLAINTEXT").setHost("localhost").setPort(9092));
QuorumController active = controlEnv.activeController();
MockRaftClient mockRaftClient = clientEnv
.raftClients()
.stream()
.filter(logManager -> logManager.nodeId().equals(OptionalInt.of(active.nodeId())))
.findAny()
.get();
TestUtils.waitForCondition(
() -> mockRaftClient.highWatermark().isPresent(),
maxReplicationDelayMs,
"High watermark was not established"
);
final long firstHighWatermark = mockRaftClient.highWatermark().getAsLong();
TestUtils.waitForCondition(
() -> mockRaftClient.highWatermark().getAsLong() > firstHighWatermark,
maxReplicationDelayMs,
"Active controller didn't write NoOpRecord the first time"
);
// Do it again to make sure that we are not counting the leader change record
final long secondHighWatermark = mockRaftClient.highWatermark().getAsLong();
TestUtils.waitForCondition(
() -> mockRaftClient.highWatermark().getAsLong() > secondHighWatermark,
maxReplicationDelayMs,
"Active controller didn't write NoOpRecord the second time"
);
}
}
@ParameterizedTest
@CsvSource(value = {"0, 0", "0, 1", "1, 0", "1, 1"})
public void testRegisterBrokerKRaftVersions(short finalizedKraftVersion, short brokerMaxSupportedKraftVersion) throws Throwable {
try (
MockRaftClientTestEnv clientEnv = new MockRaftClientTestEnv.Builder(1).
setLastKRaftVersion(KRaftVersion.fromFeatureLevel(finalizedKraftVersion)).
build();
QuorumControllerTestEnv controlEnv = new QuorumControllerTestEnv.Builder(clientEnv).
setBootstrapMetadata(SIMPLE_BOOTSTRAP).
build()
) {
ListenerCollection listeners = new ListenerCollection();
listeners.add(new Listener().setName("PLAINTEXT").
setHost("localhost").setPort(9092));
QuorumController active = controlEnv.activeController();
BrokerRegistrationRequestData.FeatureCollection brokerFeatures = new BrokerRegistrationRequestData.FeatureCollection();
brokerFeatures.add(new BrokerRegistrationRequestData.Feature()
.setName(MetadataVersion.FEATURE_NAME)
.setMinSupportedVersion(MetadataVersion.MINIMUM_VERSION.featureLevel())
.setMaxSupportedVersion(MetadataVersion.latestTesting().featureLevel()));
// broker registration requests do not include initial versions of features
if (brokerMaxSupportedKraftVersion != 0) {
brokerFeatures.add(new BrokerRegistrationRequestData.Feature()
.setName(KRaftVersion.FEATURE_NAME)
.setMinSupportedVersion(Feature.KRAFT_VERSION.minimumProduction())
.setMaxSupportedVersion(brokerMaxSupportedKraftVersion));
}
BrokerRegistrationRequestData request = new BrokerRegistrationRequestData().
setBrokerId(0).
setClusterId(active.clusterId()).
setIncarnationId(Uuid.fromString("kxAT73dKQsitIedpiPtwBA")).
setFeatures(brokerFeatures).
setLogDirs(List.of(Uuid.fromString("vBpaRsZVSaGsQT53wtYGtg"))).
setListeners(listeners);
if (brokerMaxSupportedKraftVersion < finalizedKraftVersion) {
Throwable exception = assertThrows(ExecutionException.class, () -> active.registerBroker(
ANONYMOUS_CONTEXT,
request).get());
assertEquals(UnsupportedVersionException.class, exception.getCause().getClass());
assertEquals("Unable to register because the broker does not support finalized version " +
finalizedKraftVersion + " of kraft.version. The broker wants a version between 0 and " +
brokerMaxSupportedKraftVersion + ", inclusive.",
exception.getCause().getMessage());
} else {
BrokerRegistrationReply reply = active.registerBroker(
ANONYMOUS_CONTEXT,
request).get();
assertTrue(reply.epoch() >= 4, "Unexpected broker epoch " + reply.epoch());
}
}
}
@Test
public void testUnregisterBroker() throws Throwable {
try (
MockRaftClientTestEnv clientEnv = new MockRaftClientTestEnv.Builder(1).
build();
QuorumControllerTestEnv controlEnv = new QuorumControllerTestEnv.Builder(clientEnv).
build()
) {
ListenerCollection listeners = new ListenerCollection();
listeners.add(new Listener().setName("PLAINTEXT").
setHost("localhost").setPort(9092));
QuorumController active = controlEnv.activeController();
CompletableFuture<BrokerRegistrationReply> reply = active.registerBroker(
ANONYMOUS_CONTEXT,
new BrokerRegistrationRequestData().
setBrokerId(0).
setClusterId(active.clusterId()).
setIncarnationId(Uuid.fromString("kxAT73dKQsitIedpiPtwBA")).
setFeatures(brokerFeaturesPlusFeatureVersions(MetadataVersion.MINIMUM_VERSION, MetadataVersion.latestTesting(),
Map.of(EligibleLeaderReplicasVersion.FEATURE_NAME, EligibleLeaderReplicasVersion.ELRV_1.featureLevel()))).
setLogDirs(List.of(Uuid.fromString("vBpaRsZVSaGsQT53wtYGtg"))).
setListeners(listeners));
assertEquals(6L, reply.get().epoch());
CreateTopicsRequestData createTopicsRequestData =
new CreateTopicsRequestData().setTopics(
new CreatableTopicCollection(Set.of(
new CreatableTopic().setName("foo").setNumPartitions(1).
setReplicationFactor((short) 1)).iterator()));
assertEquals(Errors.INVALID_REPLICATION_FACTOR.code(), active.createTopics(
ANONYMOUS_CONTEXT,
createTopicsRequestData, Set.of("foo")).get().
topics().find("foo").errorCode());
assertEquals("Unable to replicate the partition 1 time(s): All brokers " +
"are currently fenced.", active.createTopics(ANONYMOUS_CONTEXT,
createTopicsRequestData, Set.of("foo")).
get().topics().find("foo").errorMessage());
assertEquals(new BrokerHeartbeatReply(true, false, false, false),
active.processBrokerHeartbeat(ANONYMOUS_CONTEXT, new BrokerHeartbeatRequestData().
setWantFence(false).setBrokerEpoch(6L).setBrokerId(0).
setCurrentMetadataOffset(100000L)).get());
assertEquals(Errors.NONE.code(), active.createTopics(ANONYMOUS_CONTEXT,
createTopicsRequestData, Set.of("foo")).
get().topics().find("foo").errorCode());
CompletableFuture<TopicIdPartition> topicPartitionFuture = active.appendReadEvent(
"debugGetPartition", OptionalLong.empty(), () -> {
Iterator<TopicIdPartition> iterator = active.
replicationControl().brokersToIsrs().iterator(0, true);
assertTrue(iterator.hasNext());
return iterator.next();
});
assertEquals(0, topicPartitionFuture.get().partitionId());
active.unregisterBroker(ANONYMOUS_CONTEXT, 0).get();
topicPartitionFuture = active.appendReadEvent(
"debugGetPartition", OptionalLong.empty(), () -> {
Iterator<TopicIdPartition> iterator = active.
replicationControl().brokersToIsrs().partitionsWithNoLeader();
assertTrue(iterator.hasNext());
return iterator.next();
});
assertEquals(0, topicPartitionFuture.get().partitionId());
testToImages(clientEnv.allRecords());
}
}
private RegisterBrokerRecord.BrokerFeatureCollection registrationFeatures(
MetadataVersion minVersion,
MetadataVersion maxVersion
) {
RegisterBrokerRecord.BrokerFeatureCollection features = new RegisterBrokerRecord.BrokerFeatureCollection();
features.add(new RegisterBrokerRecord.BrokerFeature().
setName(MetadataVersion.FEATURE_NAME).
setMinSupportedVersion(minVersion.featureLevel()).
setMaxSupportedVersion(maxVersion.featureLevel()));
return features;
}
@Test
public void testSnapshotSaveAndLoad() throws Throwable {
final int numBrokers = 4;
Map<Integer, Long> brokerEpochs = new HashMap<>();
Uuid fooId;
try (
MockRaftClientTestEnv clientEnv = new MockRaftClientTestEnv.Builder(3).
build();
QuorumControllerTestEnv controlEnv = new QuorumControllerTestEnv.Builder(clientEnv).
setBootstrapMetadata(SIMPLE_BOOTSTRAP).
build()
) {
QuorumController active = controlEnv.activeController();
for (int i = 0; i < clientEnv.raftClients().size(); i++) {
active.registerController(ANONYMOUS_CONTEXT,
new ControllerRegistrationRequestData().
setControllerId(i).
setIncarnationId(new Uuid(3465346L, i)).
setZkMigrationReady(false).
setListeners(new ControllerRegistrationRequestData.ListenerCollection(
List.of(
new ControllerRegistrationRequestData.Listener().
setName("CONTROLLER").
setHost("localhost").
setPort(8000 + i).
setSecurityProtocol(SecurityProtocol.PLAINTEXT.id)
).iterator()
)).
setFeatures(new ControllerRegistrationRequestData.FeatureCollection(
List.of(
new ControllerRegistrationRequestData.Feature().
setName(MetadataVersion.FEATURE_NAME).
setMinSupportedVersion(MetadataVersion.MINIMUM_VERSION.featureLevel()).
setMaxSupportedVersion(MetadataVersion.IBP_3_7_IV0.featureLevel())
).iterator()
))).get();
}
for (int i = 0; i < numBrokers; i++) {
BrokerRegistrationReply reply = active.registerBroker(ANONYMOUS_CONTEXT,
new BrokerRegistrationRequestData().
setBrokerId(i).
setRack(null).
setClusterId(active.clusterId()).
setFeatures(brokerFeatures(MetadataVersion.MINIMUM_VERSION, MetadataVersion.IBP_3_7_IV0)).
setIncarnationId(Uuid.fromString("kxAT73dKQsitIedpiPtwB" + i)).
setListeners(new ListenerCollection(List.of(new Listener().
setName("PLAINTEXT").setHost("localhost").
setPort(9092 + i)).iterator()))).get();
brokerEpochs.put(i, reply.epoch());
}
for (int i = 0; i < numBrokers - 1; i++) {
assertEquals(new BrokerHeartbeatReply(true, false, false, false),
active.processBrokerHeartbeat(ANONYMOUS_CONTEXT, new BrokerHeartbeatRequestData().
setWantFence(false).setBrokerEpoch(brokerEpochs.get(i)).
setBrokerId(i).setCurrentMetadataOffset(100000L)).get());
}
CreateTopicsResponseData fooData = active.createTopics(ANONYMOUS_CONTEXT,
new CreateTopicsRequestData().setTopics(
new CreatableTopicCollection(Set.of(
new CreatableTopic().setName("foo").setNumPartitions(-1).
setReplicationFactor((short) -1).
setAssignments(new CreatableReplicaAssignmentCollection(
List.of(new CreatableReplicaAssignment().
setPartitionIndex(0).
setBrokerIds(List.of(0, 1, 2)),
new CreatableReplicaAssignment().
setPartitionIndex(1).
setBrokerIds(List.of(1, 2, 0))).
iterator()))).iterator())),
Set.of("foo")).get();
fooId = fooData.topics().find("foo").topicId();
active.allocateProducerIds(ANONYMOUS_CONTEXT,
new AllocateProducerIdsRequestData().setBrokerId(0).setBrokerEpoch(brokerEpochs.get(0))).get();
controlEnv.close();
assertEquals(generateTestRecords(fooId, brokerEpochs), clientEnv.allRecords());
testToImages(clientEnv.allRecords());
}
}
private List<ApiMessageAndVersion> generateTestRecords(Uuid fooId, Map<Integer, Long> brokerEpochs) {
return List.of(
new ApiMessageAndVersion(new BeginTransactionRecord().
setName("Bootstrap records"), (short) 0),
new ApiMessageAndVersion(new FeatureLevelRecord().
setName(MetadataVersion.FEATURE_NAME).
setFeatureLevel(MetadataVersion.IBP_3_7_IV0.featureLevel()), (short) 0),
new ApiMessageAndVersion(new EndTransactionRecord(), (short) 0),
new ApiMessageAndVersion(new RegisterControllerRecord().
setControllerId(0).
setIncarnationId(Uuid.fromString("AAAAAAA04IIAAAAAAAAAAA")).
setEndPoints(new RegisterControllerRecord.ControllerEndpointCollection(
List.of(
new RegisterControllerRecord.ControllerEndpoint().
setName("CONTROLLER").
setHost("localhost").
setPort(8000).
setSecurityProtocol(SecurityProtocol.PLAINTEXT.id)).iterator())).
setFeatures(new RegisterControllerRecord.ControllerFeatureCollection(
List.of(
new RegisterControllerRecord.ControllerFeature().
setName(MetadataVersion.FEATURE_NAME).
setMinSupportedVersion(MetadataVersion.MINIMUM_VERSION.featureLevel()).
setMaxSupportedVersion(MetadataVersion.IBP_3_7_IV0.featureLevel())).iterator())),
(short) 0),
new ApiMessageAndVersion(new RegisterControllerRecord().
setControllerId(1).
setIncarnationId(Uuid.fromString("AAAAAAA04IIAAAAAAAAAAQ")).
setEndPoints(new RegisterControllerRecord.ControllerEndpointCollection(
List.of(
new RegisterControllerRecord.ControllerEndpoint().
setName("CONTROLLER").
setHost("localhost").
setPort(8001).
setSecurityProtocol(SecurityProtocol.PLAINTEXT.id)).iterator())).
setFeatures(new RegisterControllerRecord.ControllerFeatureCollection(
List.of(
new RegisterControllerRecord.ControllerFeature().
setName(MetadataVersion.FEATURE_NAME).
setMinSupportedVersion(MetadataVersion.MINIMUM_VERSION.featureLevel()).
setMaxSupportedVersion(MetadataVersion.IBP_3_7_IV0.featureLevel())).iterator())),
(short) 0),
new ApiMessageAndVersion(new RegisterControllerRecord().
setControllerId(2).
setIncarnationId(Uuid.fromString("AAAAAAA04IIAAAAAAAAAAg")).
setEndPoints(new RegisterControllerRecord.ControllerEndpointCollection(
List.of(
new RegisterControllerRecord.ControllerEndpoint().
setName("CONTROLLER").
setHost("localhost").
setPort(8002).
setSecurityProtocol(SecurityProtocol.PLAINTEXT.id)).iterator())).
setFeatures(new RegisterControllerRecord.ControllerFeatureCollection(
List.of(
new RegisterControllerRecord.ControllerFeature().
setName(MetadataVersion.FEATURE_NAME).
setMinSupportedVersion(MetadataVersion.MINIMUM_VERSION.featureLevel()).
setMaxSupportedVersion(MetadataVersion.IBP_3_7_IV0.featureLevel())).iterator())),
(short) 0),
new ApiMessageAndVersion(new RegisterBrokerRecord().
setBrokerId(0).setBrokerEpoch(brokerEpochs.get(0)).
setIncarnationId(Uuid.fromString("kxAT73dKQsitIedpiPtwB0")).
setEndPoints(new BrokerEndpointCollection(
List.of(new BrokerEndpoint().setName("PLAINTEXT").setHost("localhost").
setPort(9092).setSecurityProtocol((short) 0)).iterator())).
setFeatures(registrationFeatures(MetadataVersion.MINIMUM_VERSION, MetadataVersion.IBP_3_7_IV0)).
setRack(null).
setFenced(true), (short) 2),
new ApiMessageAndVersion(new RegisterBrokerRecord().
setBrokerId(1).setBrokerEpoch(brokerEpochs.get(1)).
setIncarnationId(Uuid.fromString("kxAT73dKQsitIedpiPtwB1")).
setEndPoints(new BrokerEndpointCollection(List.of(
new BrokerEndpoint().setName("PLAINTEXT").setHost("localhost").
setPort(9093).setSecurityProtocol((short) 0)).iterator())).
setFeatures(registrationFeatures(MetadataVersion.MINIMUM_VERSION, MetadataVersion.IBP_3_7_IV0)).
setRack(null).
setFenced(true), (short) 2),
new ApiMessageAndVersion(new RegisterBrokerRecord().
setBrokerId(2).setBrokerEpoch(brokerEpochs.get(2)).
setIncarnationId(Uuid.fromString("kxAT73dKQsitIedpiPtwB2")).
setEndPoints(new BrokerEndpointCollection(
List.of(new BrokerEndpoint().setName("PLAINTEXT").setHost("localhost").
setPort(9094).setSecurityProtocol((short) 0)).iterator())).
setFeatures(registrationFeatures(MetadataVersion.MINIMUM_VERSION, MetadataVersion.IBP_3_7_IV0)).
setRack(null).
setFenced(true), (short) 2),
new ApiMessageAndVersion(new RegisterBrokerRecord().
setBrokerId(3).setBrokerEpoch(brokerEpochs.get(3)).
setIncarnationId(Uuid.fromString("kxAT73dKQsitIedpiPtwB3")).
setEndPoints(new BrokerEndpointCollection(List.of(
new BrokerEndpoint().setName("PLAINTEXT").setHost("localhost").
setPort(9095).setSecurityProtocol((short) 0)).iterator())).
setFeatures(registrationFeatures(MetadataVersion.MINIMUM_VERSION, MetadataVersion.IBP_3_7_IV0)).
setRack(null).
setFenced(true), (short) 2),
new ApiMessageAndVersion(new BrokerRegistrationChangeRecord().
setBrokerId(0).
setBrokerEpoch(brokerEpochs.get(0)).
setFenced(BrokerRegistrationFencingChange.UNFENCE.value()), (short) 0),
new ApiMessageAndVersion(new BrokerRegistrationChangeRecord().
setBrokerId(1).
setBrokerEpoch(brokerEpochs.get(1)).
setFenced(BrokerRegistrationFencingChange.UNFENCE.value()), (short) 0),
new ApiMessageAndVersion(new BrokerRegistrationChangeRecord().
setBrokerId(2).
setBrokerEpoch(brokerEpochs.get(2)).
setFenced(BrokerRegistrationFencingChange.UNFENCE.value()), (short) 0),
new ApiMessageAndVersion(new TopicRecord().
setName("foo").setTopicId(fooId), (short) 0),
new ApiMessageAndVersion(new PartitionRecord().setPartitionId(0).
setTopicId(fooId).setReplicas(List.of(0, 1, 2)).
setIsr(List.of(0, 1, 2)).setRemovingReplicas(List.of()).
setAddingReplicas(List.of()).setLeader(0).setLeaderEpoch(0).
setPartitionEpoch(0), (short) 0),
new ApiMessageAndVersion(new PartitionRecord().setPartitionId(1).
setTopicId(fooId).setReplicas(List.of(1, 2, 0)).
setIsr(List.of(1, 2, 0)).setRemovingReplicas(List.of()).
setAddingReplicas(List.of()).setLeader(1).setLeaderEpoch(0).
setPartitionEpoch(0), (short) 0),
new ApiMessageAndVersion(new ProducerIdsRecord().
setBrokerId(0).
setBrokerEpoch(brokerEpochs.get(0)).
setNextProducerId(1000), (short) 0));
}
/**
* Test that certain controller operations time out if they stay on the controller
* queue for too long.
*/
@Test
public void testTimeouts() throws Throwable {
try (
MockRaftClientTestEnv clientEnv = new MockRaftClientTestEnv.Builder(1).build();
QuorumControllerTestEnv controlEnv = new QuorumControllerTestEnv.Builder(clientEnv).
build()
) {
QuorumController controller = controlEnv.activeController();
CountDownLatch countDownLatch = pause(controller);
long now = controller.time().nanoseconds();
ControllerRequestContext context0 = new ControllerRequestContext(
new RequestHeaderData(), KafkaPrincipal.ANONYMOUS, OptionalLong.of(now));
CompletableFuture<CreateTopicsResponseData> createFuture =
controller.createTopics(context0, new CreateTopicsRequestData().setTimeoutMs(0).
setTopics(new CreatableTopicCollection(Set.of(
new CreatableTopic().setName("foo")).iterator())),
Set.of());
CompletableFuture<Map<Uuid, ApiError>> deleteFuture =
controller.deleteTopics(context0, List.of(Uuid.ZERO_UUID));
CompletableFuture<Map<String, ResultOrError<Uuid>>> findTopicIdsFuture =
controller.findTopicIds(context0, List.of("foo"));
CompletableFuture<Map<Uuid, ResultOrError<String>>> findTopicNamesFuture =
controller.findTopicNames(context0, List.of(Uuid.ZERO_UUID));
CompletableFuture<List<CreatePartitionsTopicResult>> createPartitionsFuture =
controller.createPartitions(context0, List.of(
new CreatePartitionsTopic()), false);
CompletableFuture<ElectLeadersResponseData> electLeadersFuture =
controller.electLeaders(context0, new ElectLeadersRequestData().setTimeoutMs(0).
setTopicPartitions(null));
CompletableFuture<AlterPartitionReassignmentsResponseData> alterReassignmentsFuture =
controller.alterPartitionReassignments(context0,
new AlterPartitionReassignmentsRequestData().setTimeoutMs(0).
setTopics(List.of(new ReassignableTopic())));
CompletableFuture<ListPartitionReassignmentsResponseData> listReassignmentsFuture =
controller.listPartitionReassignments(context0,
new ListPartitionReassignmentsRequestData().setTopics(null).setTimeoutMs(0));
while (controller.time().nanoseconds() == now) {
Thread.sleep(0, 10);
}
countDownLatch.countDown();
assertYieldsTimeout(createFuture);
assertYieldsTimeout(deleteFuture);
assertYieldsTimeout(findTopicIdsFuture);
assertYieldsTimeout(findTopicNamesFuture);
assertYieldsTimeout(createPartitionsFuture);
assertYieldsTimeout(electLeadersFuture);
assertYieldsTimeout(alterReassignmentsFuture);
assertYieldsTimeout(listReassignmentsFuture);
testToImages(clientEnv.allRecords());
}
}
private static void assertYieldsTimeout(Future<?> future) {
assertEquals(TimeoutException.class, assertThrows(ExecutionException.class, future::get).getCause().getClass());
}
/**
* Test that certain controller operations finish immediately without putting an event
* on the controller queue, if there is nothing to do.
*/
@Test
public void testEarlyControllerResults() throws Throwable {
try (
MockRaftClientTestEnv clientEnv = new MockRaftClientTestEnv.Builder(1).
build();
QuorumControllerTestEnv controlEnv = new QuorumControllerTestEnv.Builder(clientEnv).
build()
) {
QuorumController controller = controlEnv.activeController();
CountDownLatch countDownLatch = pause(controller);
CompletableFuture<CreateTopicsResponseData> createFuture =
controller.createTopics(ANONYMOUS_CONTEXT, new CreateTopicsRequestData().
setTimeoutMs(120000), Set.of());
CompletableFuture<Map<Uuid, ApiError>> deleteFuture =
controller.deleteTopics(ANONYMOUS_CONTEXT, List.of());
CompletableFuture<Map<String, ResultOrError<Uuid>>> findTopicIdsFuture =
controller.findTopicIds(ANONYMOUS_CONTEXT, List.of());
CompletableFuture<Map<Uuid, ResultOrError<String>>> findTopicNamesFuture =
controller.findTopicNames(ANONYMOUS_CONTEXT, List.of());
CompletableFuture<List<CreatePartitionsTopicResult>> createPartitionsFuture =
controller.createPartitions(ANONYMOUS_CONTEXT, List.of(), false);
CompletableFuture<ElectLeadersResponseData> electLeadersFuture =
controller.electLeaders(ANONYMOUS_CONTEXT, new ElectLeadersRequestData());
CompletableFuture<AlterPartitionReassignmentsResponseData> alterReassignmentsFuture =
controller.alterPartitionReassignments(ANONYMOUS_CONTEXT,
new AlterPartitionReassignmentsRequestData());
createFuture.get();
deleteFuture.get();
findTopicIdsFuture.get();
findTopicNamesFuture.get();
createPartitionsFuture.get();
electLeadersFuture.get();
alterReassignmentsFuture.get();
countDownLatch.countDown();
testToImages(clientEnv.allRecords());
}
}
@Test
public void testConfigResourceExistenceChecker() throws Throwable {
try (
MockRaftClientTestEnv clientEnv = new MockRaftClientTestEnv.Builder(3).
build();
QuorumControllerTestEnv controlEnv = new QuorumControllerTestEnv.Builder(clientEnv).
build()
) {
QuorumController active = controlEnv.activeController();
registerBrokersAndUnfence(active, 5);
active.createTopics(ANONYMOUS_CONTEXT, new CreateTopicsRequestData().
setTopics(new CreatableTopicCollection(Set.of(
new CreatableTopic().setName("foo").
setReplicationFactor((short) 3).
setNumPartitions(1)).iterator())),
Set.of("foo")).get();
ConfigResourceExistenceChecker checker =
active.new ConfigResourceExistenceChecker();
// A ConfigResource with type=BROKER and name=(empty string) represents
// the default broker resource. It is used to set cluster configs.
checker.accept(new ConfigResource(BROKER, ""));
// Broker 3 exists, so we can set a configuration for it.
checker.accept(new ConfigResource(BROKER, "3"));
// Broker 10 does not exist, so this should throw an exception.
assertThrows(BrokerIdNotRegisteredException.class,
() -> checker.accept(new ConfigResource(BROKER, "10")));
// Topic foo exists, so we can set a configuration for it.
checker.accept(new ConfigResource(TOPIC, "foo"));
// Topic bar does not exist, so this should throw an exception.
assertThrows(UnknownTopicOrPartitionException.class,
() -> checker.accept(new ConfigResource(TOPIC, "bar")));
testToImages(clientEnv.allRecords());
}
}
@Test
public void testFatalMetadataReplayErrorOnActive() throws Throwable {
try (
MockRaftClientTestEnv clientEnv = new MockRaftClientTestEnv.Builder(3).
build();
QuorumControllerTestEnv controlEnv = new QuorumControllerTestEnv.Builder(clientEnv).
build()
) {
QuorumController active = controlEnv.activeController();
CompletableFuture<Void> future = active.appendWriteEvent("errorEvent",
OptionalLong.empty(), () -> ControllerResult.of(List.of(new ApiMessageAndVersion(
new ConfigRecord().
setName(null).
setResourceName(null).
setResourceType((byte) 255).
setValue(null), (short) 0)), null));
assertThrows(ExecutionException.class, future::get);
assertEquals(NullPointerException.class, controlEnv.fatalFaultHandler(active.nodeId())
.firstException().getCause().getClass());
controlEnv.ignoreFatalFaults();
}
}
@Test
public void testFatalMetadataErrorDuringSnapshotLoading() throws Exception {
InitialSnapshot invalidSnapshot = new InitialSnapshot(List.of(
new ApiMessageAndVersion(new PartitionRecord(), (short) 0))
);
MockRaftClientTestEnv.Builder clientEnvBuilder = new MockRaftClientTestEnv.Builder(3)
.setSnapshotReader(FileRawSnapshotReader.open(
invalidSnapshot.tempDir.toPath(),
new OffsetAndEpoch(0, 0)
));
try (MockRaftClientTestEnv clientEnv = clientEnvBuilder.build()) {
try (QuorumControllerTestEnv controlEnv = new QuorumControllerTestEnv.Builder(clientEnv).build()) {
TestUtils.waitForCondition(() -> controlEnv.controllers().stream().allMatch(
controller -> controlEnv.fatalFaultHandler(controller.nodeId()).firstException() != null),
"At least one controller failed to detect the fatal fault"
);
controlEnv.ignoreFatalFaults();
}
}
}
@Test
public void testFatalMetadataErrorDuringLogLoading() throws Exception {
try (MockRaftClientTestEnv clientEnv = new MockRaftClientTestEnv.Builder(3).build()) {
clientEnv.appendInitialRecords(List.of(
new ApiMessageAndVersion(new PartitionRecord(), (short) 0)));
try (QuorumControllerTestEnv controlEnv = new QuorumControllerTestEnv.Builder(clientEnv).build()) {
TestUtils.waitForCondition(() -> controlEnv.controllers().stream().allMatch(
controller -> controlEnv.fatalFaultHandler(controller.nodeId()).firstException() != null),
"At least one controller failed to detect the fatal fault"
);
controlEnv.ignoreFatalFaults();
}
}
}
static | QuorumControllerTest |
java | alibaba__fastjson | src/test/java/com/alibaba/json/bvt/issue_1000/Issue1080.java | {
"start": 185,
"end": 774
} | class ____ extends TestCase {
public void test_for_issue() throws Exception {
java.util.Date date = JSON.parseObject("\"2017-3-17 00:00:01\"", java.util.Date.class);
String json = JSON.toJSONStringWithDateFormat(date, "yyyy-MM-dd");
assertEquals("\"2017-03-17\"", json);
}
public void test_for_issue_2() throws Exception {
java.util.Date date = JSON.parseObject("\"2017-3-7 00:00:01\"", java.util.Date.class);
String json = JSON.toJSONStringWithDateFormat(date, "yyyy-MM-dd");
assertEquals("\"2017-03-07\"", json);
}
}
| Issue1080 |
java | apache__hadoop | hadoop-hdfs-project/hadoop-hdfs/src/test/java/org/apache/hadoop/hdfs/server/blockmanagement/TestHostFileManager.java | {
"start": 1506,
"end": 6457
} | class ____ {
private static InetSocketAddress entry(String e) {
return HostFileManager.parseEntry("dummy", "dummy", e);
}
@Test
public void testDeduplication() {
HostSet s = new HostSet();
// These entries will be de-duped, since they refer to the same IP
// address + port combo.
s.add(entry("127.0.0.1:12345"));
s.add(entry("localhost:12345"));
assertEquals(1, s.size());
s.add(entry("127.0.0.1:12345"));
assertEquals(1, s.size());
// The following entries should not be de-duped.
s.add(entry("127.0.0.1:12346"));
assertEquals(2, s.size());
s.add(entry("127.0.0.1"));
assertEquals(3, s.size());
s.add(entry("127.0.0.10"));
assertEquals(4, s.size());
}
@Test
public void testRelation() {
HostSet s = new HostSet();
s.add(entry("127.0.0.1:123"));
assertTrue(s.match(entry("127.0.0.1:123")));
assertFalse(s.match(entry("127.0.0.1:12")));
assertFalse(s.match(entry("127.0.0.1")));
assertFalse(s.matchedBy(entry("127.0.0.1:12")));
assertTrue(s.matchedBy(entry("127.0.0.1")));
assertTrue(s.matchedBy(entry("127.0.0.1:123")));
assertFalse(s.match(entry("127.0.0.2")));
assertFalse(s.match(entry("127.0.0.2:123")));
assertFalse(s.matchedBy(entry("127.0.0.2")));
assertFalse(s.matchedBy(entry("127.0.0.2:123")));
s.add(entry("127.0.0.1"));
assertTrue(s.match(entry("127.0.0.1:123")));
assertTrue(s.match(entry("127.0.0.1:12")));
assertTrue(s.match(entry("127.0.0.1")));
assertFalse(s.matchedBy(entry("127.0.0.1:12")));
assertTrue(s.matchedBy(entry("127.0.0.1")));
assertTrue(s.matchedBy(entry("127.0.0.1:123")));
assertFalse(s.match(entry("127.0.0.2")));
assertFalse(s.match(entry("127.0.0.2:123")));
assertFalse(s.matchedBy(entry("127.0.0.2")));
assertFalse(s.matchedBy(entry("127.0.0.2:123")));
s.add(entry("127.0.0.2:123"));
assertTrue(s.match(entry("127.0.0.1:123")));
assertTrue(s.match(entry("127.0.0.1:12")));
assertTrue(s.match(entry("127.0.0.1")));
assertFalse(s.matchedBy(entry("127.0.0.1:12")));
assertTrue(s.matchedBy(entry("127.0.0.1")));
assertTrue(s.matchedBy(entry("127.0.0.1:123")));
assertFalse(s.match(entry("127.0.0.2")));
assertTrue(s.match(entry("127.0.0.2:123")));
assertTrue(s.matchedBy(entry("127.0.0.2")));
assertTrue(s.matchedBy(entry("127.0.0.2:123")));
}
@Test
@SuppressWarnings("unchecked")
public void testIncludeExcludeLists() throws IOException {
BlockManager bm = mock(BlockManager.class);
FSNamesystem fsn = mock(FSNamesystem.class);
Configuration conf = new Configuration();
HostFileManager hm = new HostFileManager();
HostSet includedNodes = new HostSet();
HostSet excludedNodes = new HostSet();
includedNodes.add(entry("127.0.0.1:12345"));
includedNodes.add(entry("localhost:12345"));
includedNodes.add(entry("127.0.0.1:12345"));
includedNodes.add(entry("127.0.0.2"));
excludedNodes.add(entry("127.0.0.1:12346"));
excludedNodes.add(entry("127.0.30.1:12346"));
assertEquals(2, includedNodes.size());
assertEquals(2, excludedNodes.size());
hm.refresh(includedNodes, excludedNodes);
DatanodeManager dm = new DatanodeManager(bm, fsn, conf);
Whitebox.setInternalState(dm, "hostConfigManager", hm);
Map<String, DatanodeDescriptor> dnMap = (Map<String,
DatanodeDescriptor>) Whitebox.getInternalState(dm, "datanodeMap");
// After the de-duplication, there should be only one DN from the included
// nodes declared as dead.
assertEquals(2,
dm.getDatanodeListForReport(HdfsConstants.DatanodeReportType.ALL).size());
assertEquals(2,
dm.getDatanodeListForReport(HdfsConstants.DatanodeReportType.DEAD).size());
dnMap.put("uuid-foo", new DatanodeDescriptor(new DatanodeID("127.0.0.1",
"localhost", "uuid-foo", 12345, 1020, 1021, 1022)));
assertEquals(1,
dm.getDatanodeListForReport(HdfsConstants.DatanodeReportType.DEAD).size());
dnMap.put("uuid-bar", new DatanodeDescriptor(new DatanodeID("127.0.0.2",
"127.0.0.2", "uuid-bar", 12345, 1020, 1021, 1022)));
assertEquals(0,
dm.getDatanodeListForReport(HdfsConstants.DatanodeReportType.DEAD).size());
DatanodeDescriptor spam = new DatanodeDescriptor(new DatanodeID("127.0.0" +
".3", "127.0.0.3", "uuid-spam", 12345, 1020, 1021, 1022));
DFSTestUtil.setDatanodeDead(spam);
includedNodes.add(entry("127.0.0.3:12345"));
dnMap.put("uuid-spam", spam);
assertEquals(1,
dm.getDatanodeListForReport(HdfsConstants.DatanodeReportType.DEAD).size());
dnMap.remove("uuid-spam");
assertEquals(1,
dm.getDatanodeListForReport(HdfsConstants.DatanodeReportType.DEAD).size());
excludedNodes.add(entry("127.0.0.3"));
assertEquals(1,
dm.getDatanodeListForReport(HdfsConstants.DatanodeReportType.DEAD).size());
}
}
| TestHostFileManager |
java | apache__hadoop | hadoop-mapreduce-project/hadoop-mapreduce-client/hadoop-mapreduce-client-app/src/main/java/org/apache/hadoop/mapreduce/v2/app/job/impl/TaskAttemptImpl.java | {
"start": 79769,
"end": 82452
} | class ____ implements
SingleArcTransition<TaskAttemptImpl, TaskAttemptEvent> {
private final TaskAttemptStateInternal finalState;
private final boolean withdrawsContainerRequest;
DeallocateContainerTransition
(TaskAttemptStateInternal finalState, boolean withdrawsContainerRequest) {
this.finalState = finalState;
this.withdrawsContainerRequest = withdrawsContainerRequest;
}
@SuppressWarnings("unchecked")
@Override
public void transition(TaskAttemptImpl taskAttempt,
TaskAttemptEvent event) {
if (taskAttempt.getLaunchTime() == 0) {
sendJHStartEventForAssignedFailTask(taskAttempt);
}
//set the finish time
taskAttempt.setFinishTime();
if (event instanceof TaskAttemptKillEvent) {
taskAttempt.addDiagnosticInfo(
((TaskAttemptKillEvent) event).getMessage());
}
//send the deallocate event to ContainerAllocator
taskAttempt.eventHandler.handle(
new ContainerAllocatorEvent(taskAttempt.attemptId,
ContainerAllocator.EventType.CONTAINER_DEALLOCATE));
// send event to speculator that we withdraw our container needs, if
// we're transitioning out of UNASSIGNED
if (withdrawsContainerRequest) {
taskAttempt.eventHandler.handle
(new SpeculatorEvent(taskAttempt.getID().getTaskId(), -1));
}
switch(finalState) {
case FAILED:
boolean fastFail = false;
if (event instanceof TaskAttemptFailEvent) {
fastFail = ((TaskAttemptFailEvent) event).isFastFail();
}
taskAttempt.eventHandler.handle(new TaskTAttemptFailedEvent(
taskAttempt.attemptId, fastFail));
break;
case KILLED:
taskAttempt.eventHandler.handle(new TaskTAttemptKilledEvent(
taskAttempt.attemptId, false));
break;
default:
LOG.error("Task final state is not FAILED or KILLED: " + finalState);
}
TaskAttemptUnsuccessfulCompletionEvent tauce =
createTaskAttemptUnsuccessfulCompletionEvent(taskAttempt,
finalState);
if(finalState == TaskAttemptStateInternal.FAILED) {
taskAttempt.eventHandler
.handle(createJobCounterUpdateEventTAFailed(taskAttempt, false));
} else if(finalState == TaskAttemptStateInternal.KILLED) {
taskAttempt.eventHandler
.handle(createJobCounterUpdateEventTAKilled(taskAttempt, false));
}
taskAttempt.eventHandler.handle(new JobHistoryEvent(
taskAttempt.attemptId.getTaskId().getJobId(), tauce));
}
}
private static | DeallocateContainerTransition |
java | apache__camel | dsl/camel-jbang/camel-jbang-core/src/test/java/org/apache/camel/dsl/jbang/core/commands/bind/BindTest.java | {
"start": 1114,
"end": 36663
} | class ____ extends CamelCommandBaseTest {
@Test
public void shouldBindKameletSourceToKameletSink() throws Exception {
Bind command = createCommand("timer", "log");
command.doCall();
String output = printer.getOutput();
Assertions.assertEquals("""
apiVersion: camel.apache.org/v1
kind: Pipe
metadata:
name: timer-to-log
spec:
source:
ref:
kind: Kamelet
apiVersion: camel.apache.org/v1
name: timer-source
properties:
message: "hello world"
sink:
ref:
kind: Kamelet
apiVersion: camel.apache.org/v1
name: log-sink
#properties:
#key: "value"
""".trim(), output);
}
@Test
public void shouldBindNamespacedKamelets() throws Exception {
Bind command = createCommand("timer", "log");
command.source = "my-namespace/timer-source";
command.sink = "my-namespace/log-sink";
command.doCall();
String output = printer.getOutput();
Assertions.assertEquals("""
apiVersion: camel.apache.org/v1
kind: Pipe
metadata:
name: timer-to-log
spec:
source:
ref:
kind: Kamelet
apiVersion: camel.apache.org/v1
name: timer-source
namespace: my-namespace
properties:
message: "hello world"
sink:
ref:
kind: Kamelet
apiVersion: camel.apache.org/v1
name: log-sink
namespace: my-namespace
#properties:
#key: "value"
""".trim(), output);
}
@Test
public void shouldBindKameletsExplicitPrefix() throws Exception {
Bind command = createCommand("timer", "log");
command.source = "kamelet:timer-source";
command.sink = "kamelet:log-sink";
command.doCall();
String output = printer.getOutput();
Assertions.assertEquals("""
apiVersion: camel.apache.org/v1
kind: Pipe
metadata:
name: timer-to-log
spec:
source:
ref:
kind: Kamelet
apiVersion: camel.apache.org/v1
name: timer-source
properties:
message: "hello world"
sink:
ref:
kind: Kamelet
apiVersion: camel.apache.org/v1
name: log-sink
#properties:
#key: "value"
""".trim(), output);
}
@Test
public void shouldBindKameletSourceToKameletSinkWithProperties() throws Exception {
Bind command = createCommand("timer", "log");
command.properties = new String[] {
"source.message=Hello",
"source.period=5000",
"sink.showHeaders=true",
};
command.doCall();
String output = printer.getOutput();
Assertions.assertEquals("""
apiVersion: camel.apache.org/v1
kind: Pipe
metadata:
name: timer-to-log
spec:
source:
ref:
kind: Kamelet
apiVersion: camel.apache.org/v1
name: timer-source
properties:
message: Hello
period: 5000
sink:
ref:
kind: Kamelet
apiVersion: camel.apache.org/v1
name: log-sink
properties:
showHeaders: true
""".trim(), output);
}
@Test
public void shouldBindKameletsWithUriProperties() throws Exception {
Bind command = createCommand("timer", "log");
command.source = "timer-source?message=Hi";
command.sink = "log-sink?showHeaders=true";
command.doCall();
String output = printer.getOutput();
Assertions.assertEquals("""
apiVersion: camel.apache.org/v1
kind: Pipe
metadata:
name: timer-to-log
spec:
source:
ref:
kind: Kamelet
apiVersion: camel.apache.org/v1
name: timer-source
properties:
message: Hi
sink:
ref:
kind: Kamelet
apiVersion: camel.apache.org/v1
name: log-sink
properties:
showHeaders: true
""".trim(), output);
}
@Test
public void shouldBindWithSteps() throws Exception {
Bind command = createCommand("timer", "http");
command.steps = new String[] {
"set-body-action",
"log-action"
};
command.doCall();
String output = printer.getOutput();
Assertions.assertEquals("""
apiVersion: camel.apache.org/v1
kind: Pipe
metadata:
name: timer-to-http
spec:
source:
ref:
kind: Kamelet
apiVersion: camel.apache.org/v1
name: timer-source
properties:
message: "hello world"
steps:
- ref:
kind: Kamelet
apiVersion: camel.apache.org/v1
name: set-body-action
properties:
value: "value"
- ref:
kind: Kamelet
apiVersion: camel.apache.org/v1
name: log-action
#properties:
#key: "value"
sink:
ref:
kind: Kamelet
apiVersion: camel.apache.org/v1
name: http-sink
properties:
url: "https://my-service/path"
""".trim(), output);
}
@Test
public void shouldBindWithUriSteps() throws Exception {
Bind command = createCommand("timer", "http");
command.steps = new String[] {
"set-body-action",
"log:info"
};
command.doCall();
String output = printer.getOutput();
Assertions.assertEquals("""
apiVersion: camel.apache.org/v1
kind: Pipe
metadata:
name: timer-to-http
spec:
source:
ref:
kind: Kamelet
apiVersion: camel.apache.org/v1
name: timer-source
properties:
message: "hello world"
steps:
- ref:
kind: Kamelet
apiVersion: camel.apache.org/v1
name: set-body-action
properties:
value: "value"
- uri: log:info
#properties:
#key: "value"
sink:
ref:
kind: Kamelet
apiVersion: camel.apache.org/v1
name: http-sink
properties:
url: "https://my-service/path"
""".trim(), output);
}
@Test
public void shouldBindWithStepsAndProperties() throws Exception {
Bind command = createCommand("timer", "http");
command.steps = new String[] {
"set-body-action",
"log-action"
};
command.properties = new String[] {
"step-1.value=\"Camel rocks!\"",
"step-2.showHeaders=true",
"step-2.showExchangePattern=false"
};
command.doCall();
String output = printer.getOutput();
Assertions.assertEquals("""
apiVersion: camel.apache.org/v1
kind: Pipe
metadata:
name: timer-to-http
spec:
source:
ref:
kind: Kamelet
apiVersion: camel.apache.org/v1
name: timer-source
properties:
message: "hello world"
steps:
- ref:
kind: Kamelet
apiVersion: camel.apache.org/v1
name: set-body-action
properties:
value: "Camel rocks!"
- ref:
kind: Kamelet
apiVersion: camel.apache.org/v1
name: log-action
properties:
showHeaders: true
showExchangePattern: false
sink:
ref:
kind: Kamelet
apiVersion: camel.apache.org/v1
name: http-sink
properties:
url: "https://my-service/path"
""".trim(), output);
}
@Test
public void shouldBindWithUriStepsAndProperties() throws Exception {
Bind command = createCommand("timer", "http");
command.steps = new String[] {
"set-body-action",
"log:info"
};
command.properties = new String[] {
"step-1.value=\"Camel rocks!\"",
"step-2.showHeaders=true"
};
command.doCall();
String output = printer.getOutput();
Assertions.assertEquals("""
apiVersion: camel.apache.org/v1
kind: Pipe
metadata:
name: timer-to-http
spec:
source:
ref:
kind: Kamelet
apiVersion: camel.apache.org/v1
name: timer-source
properties:
message: "hello world"
steps:
- ref:
kind: Kamelet
apiVersion: camel.apache.org/v1
name: set-body-action
properties:
value: "Camel rocks!"
- uri: log:info
properties:
showHeaders: true
sink:
ref:
kind: Kamelet
apiVersion: camel.apache.org/v1
name: http-sink
properties:
url: "https://my-service/path"
""".trim(), output);
}
@Test
public void shouldBindWithUriStepsAndUriProperties() throws Exception {
Bind command = createCommand("timer", "http");
command.steps = new String[] {
"set-body-action",
"log:info?showExchangePattern=false&showStreams=true"
};
command.properties = new String[] {
"step-1.value=\"Camel rocks!\"",
"step-2.showHeaders=true"
};
command.doCall();
String output = printer.getOutput();
Assertions.assertEquals("""
apiVersion: camel.apache.org/v1
kind: Pipe
metadata:
name: timer-to-http
spec:
source:
ref:
kind: Kamelet
apiVersion: camel.apache.org/v1
name: timer-source
properties:
message: "hello world"
steps:
- ref:
kind: Kamelet
apiVersion: camel.apache.org/v1
name: set-body-action
properties:
value: "Camel rocks!"
- uri: log:info
properties:
showStreams: true
showHeaders: true
showExchangePattern: false
sink:
ref:
kind: Kamelet
apiVersion: camel.apache.org/v1
name: http-sink
properties:
url: "https://my-service/path"
""".trim(), output);
}
@Test
public void shouldBindKameletSourceToUri() throws Exception {
Bind command = createCommand("timer", "log:info");
command.doCall();
String output = printer.getOutput();
Assertions.assertEquals("""
apiVersion: camel.apache.org/v1
kind: Pipe
metadata:
name: timer-to-log
spec:
source:
ref:
kind: Kamelet
apiVersion: camel.apache.org/v1
name: timer-source
properties:
message: "hello world"
sink:
uri: log:info
#properties:
#key: "value"
""".trim(), output);
}
@Test
public void shouldBindKameletSourceToUriWithProperties() throws Exception {
Bind command = createCommand("timer", "log:info");
command.properties = new String[] {
"source.message=Hello",
"sink.showHeaders=true",
};
command.doCall();
String output = printer.getOutput();
Assertions.assertEquals("""
apiVersion: camel.apache.org/v1
kind: Pipe
metadata:
name: timer-to-log
spec:
source:
ref:
kind: Kamelet
apiVersion: camel.apache.org/v1
name: timer-source
properties:
message: Hello
sink:
uri: log:info
properties:
showHeaders: true
""".trim(), output);
}
@Test
public void shouldBindKameletSourceToUriWithUriProperties() throws Exception {
Bind command = createCommand("timer", "log:info?showStreams=false");
command.properties = new String[] {
"source.message=Hello",
"sink.showHeaders=true",
};
command.doCall();
String output = printer.getOutput();
Assertions.assertEquals("""
apiVersion: camel.apache.org/v1
kind: Pipe
metadata:
name: timer-to-log
spec:
source:
ref:
kind: Kamelet
apiVersion: camel.apache.org/v1
name: timer-source
properties:
message: Hello
sink:
uri: log:info
properties:
showStreams: false
showHeaders: true
""".trim(), output);
}
@Test
public void shouldBindUriToUri() throws Exception {
Bind command = createCommand("timer:tick", "log:info");
command.doCall();
String output = printer.getOutput();
Assertions.assertEquals("""
apiVersion: camel.apache.org/v1
kind: Pipe
metadata:
name: timer-to-log
spec:
source:
uri: timer:tick
#properties:
#key: "value"
sink:
uri: log:info
#properties:
#key: "value"
""".trim(), output);
}
@Test
public void shouldBindUriToUriWithProperties() throws Exception {
Bind command = createCommand("timer:tick", "log:info");
command.properties = new String[] {
"source.message=Hello",
"sink.showHeaders=true",
};
command.doCall();
String output = printer.getOutput();
Assertions.assertEquals("""
apiVersion: camel.apache.org/v1
kind: Pipe
metadata:
name: timer-to-log
spec:
source:
uri: timer:tick
properties:
message: Hello
sink:
uri: log:info
properties:
showHeaders: true
""".trim(), output);
}
@Test
public void shouldBindUriToUriWithUriProperties() throws Exception {
Bind command = createCommand("timer:tick?period=10000", "log:info?showStreams=false");
command.properties = new String[] {
"source.message=Hello",
"sink.showHeaders=true",
};
command.doCall();
String output = printer.getOutput();
Assertions.assertEquals("""
apiVersion: camel.apache.org/v1
kind: Pipe
metadata:
name: timer-to-log
spec:
source:
uri: timer:tick
properties:
period: 10000
message: Hello
sink:
uri: log:info
properties:
showStreams: false
showHeaders: true
""".trim(), output);
}
@Test
public void shouldBindKameletSinkErrorHandler() throws Exception {
Bind command = createCommand("timer", "log");
command.errorHandler = "sink:log-sink";
command.doCall();
String output = printer.getOutput();
Assertions.assertEquals("""
apiVersion: camel.apache.org/v1
kind: Pipe
metadata:
name: timer-to-log
spec:
source:
ref:
kind: Kamelet
apiVersion: camel.apache.org/v1
name: timer-source
properties:
message: "hello world"
sink:
ref:
kind: Kamelet
apiVersion: camel.apache.org/v1
name: log-sink
#properties:
#key: "value"
errorHandler:
sink:
endpoint:
ref:
kind: Kamelet
apiVersion: camel.apache.org/v1
name: log-sink
#properties:
#key: "value"
parameters: {}
""".trim(), output);
}
@Test
public void shouldBindKameletSinkErrorHandlerWithParameters() throws Exception {
Bind command = createCommand("timer", "log");
command.errorHandler = "sink:log-sink";
command.properties = new String[] {
"error-handler.maximumRedeliveries=3",
"error-handler.redeliveryDelay=2000"
};
command.doCall();
String output = printer.getOutput();
Assertions.assertEquals("""
apiVersion: camel.apache.org/v1
kind: Pipe
metadata:
name: timer-to-log
spec:
source:
ref:
kind: Kamelet
apiVersion: camel.apache.org/v1
name: timer-source
properties:
message: "hello world"
sink:
ref:
kind: Kamelet
apiVersion: camel.apache.org/v1
name: log-sink
#properties:
#key: "value"
errorHandler:
sink:
endpoint:
ref:
kind: Kamelet
apiVersion: camel.apache.org/v1
name: log-sink
#properties:
#key: "value"
parameters:
redeliveryDelay: 2000
maximumRedeliveries: 3
""".trim(), output);
}
@Test
public void shouldBindKameletSinkErrorHandlerAndSinkProperties() throws Exception {
Bind command = createCommand("timer", "log");
command.errorHandler = "sink:log-sink";
command.properties = new String[] {
"error-handler.sink.showHeaders=true",
"error-handler.maximumRedeliveries=3",
"error-handler.redeliveryDelay=2000"
};
command.doCall();
String output = printer.getOutput();
Assertions.assertEquals("""
apiVersion: camel.apache.org/v1
kind: Pipe
metadata:
name: timer-to-log
spec:
source:
ref:
kind: Kamelet
apiVersion: camel.apache.org/v1
name: timer-source
properties:
message: "hello world"
sink:
ref:
kind: Kamelet
apiVersion: camel.apache.org/v1
name: log-sink
#properties:
#key: "value"
errorHandler:
sink:
endpoint:
ref:
kind: Kamelet
apiVersion: camel.apache.org/v1
name: log-sink
properties:
showHeaders: true
parameters:
redeliveryDelay: 2000
maximumRedeliveries: 3
""".trim(), output);
}
@Test
public void shouldBindEndpointUriSinkErrorHandler() throws Exception {
Bind command = createCommand("timer", "log");
command.errorHandler = "sink:log:error";
command.doCall();
String output = printer.getOutput();
Assertions.assertEquals("""
apiVersion: camel.apache.org/v1
kind: Pipe
metadata:
name: timer-to-log
spec:
source:
ref:
kind: Kamelet
apiVersion: camel.apache.org/v1
name: timer-source
properties:
message: "hello world"
sink:
ref:
kind: Kamelet
apiVersion: camel.apache.org/v1
name: log-sink
#properties:
#key: "value"
errorHandler:
sink:
endpoint:
uri: log:error
#properties:
#key: "value"
parameters: {}
""".trim(), output);
}
@Test
public void shouldBindEndpointUriSinkErrorHandlerWithParameters() throws Exception {
Bind command = createCommand("timer", "log");
command.errorHandler = "sink:log:error";
command.properties = new String[] {
"error-handler.maximumRedeliveries=3",
"error-handler.redeliveryDelay=2000"
};
command.doCall();
String output = printer.getOutput();
Assertions.assertEquals("""
apiVersion: camel.apache.org/v1
kind: Pipe
metadata:
name: timer-to-log
spec:
source:
ref:
kind: Kamelet
apiVersion: camel.apache.org/v1
name: timer-source
properties:
message: "hello world"
sink:
ref:
kind: Kamelet
apiVersion: camel.apache.org/v1
name: log-sink
#properties:
#key: "value"
errorHandler:
sink:
endpoint:
uri: log:error
#properties:
#key: "value"
parameters:
redeliveryDelay: 2000
maximumRedeliveries: 3
""".trim(), output);
}
@Test
public void shouldBindEndpointUriSinkErrorHandlerAndSinkProperties() throws Exception {
Bind command = createCommand("timer", "log");
command.errorHandler = "sink:log:error";
command.properties = new String[] {
"error-handler.sink.showHeaders=true",
"error-handler.maximumRedeliveries=3",
"error-handler.redeliveryDelay=2000"
};
command.doCall();
String output = printer.getOutput();
Assertions.assertEquals("""
apiVersion: camel.apache.org/v1
kind: Pipe
metadata:
name: timer-to-log
spec:
source:
ref:
kind: Kamelet
apiVersion: camel.apache.org/v1
name: timer-source
properties:
message: "hello world"
sink:
ref:
kind: Kamelet
apiVersion: camel.apache.org/v1
name: log-sink
#properties:
#key: "value"
errorHandler:
sink:
endpoint:
uri: log:error
properties:
showHeaders: true
parameters:
redeliveryDelay: 2000
maximumRedeliveries: 3
""".trim(), output);
}
@Test
public void shouldBindEndpointUriSinkErrorHandlerAndUriProperties() throws Exception {
Bind command = createCommand("timer", "log");
command.errorHandler = "sink:log:error?showStreams=false";
command.properties = new String[] {
"error-handler.sink.showHeaders=true",
"error-handler.maximumRedeliveries=3",
"error-handler.redeliveryDelay=2000"
};
command.doCall();
String output = printer.getOutput();
Assertions.assertEquals("""
apiVersion: camel.apache.org/v1
kind: Pipe
metadata:
name: timer-to-log
spec:
source:
ref:
kind: Kamelet
apiVersion: camel.apache.org/v1
name: timer-source
properties:
message: "hello world"
sink:
ref:
kind: Kamelet
apiVersion: camel.apache.org/v1
name: log-sink
#properties:
#key: "value"
errorHandler:
sink:
endpoint:
uri: log:error
properties:
showStreams: false
showHeaders: true
parameters:
redeliveryDelay: 2000
maximumRedeliveries: 3
""".trim(), output);
}
@Test
public void shouldBindWithLogErrorHandler() throws Exception {
Bind command = createCommand("timer", "log");
command.errorHandler = "log";
command.doCall();
String output = printer.getOutput();
Assertions.assertEquals("""
apiVersion: camel.apache.org/v1
kind: Pipe
metadata:
name: timer-to-log
spec:
source:
ref:
kind: Kamelet
apiVersion: camel.apache.org/v1
name: timer-source
properties:
message: "hello world"
sink:
ref:
kind: Kamelet
apiVersion: camel.apache.org/v1
name: log-sink
#properties:
#key: "value"
errorHandler:
log:
parameters: {}
""".trim(), output);
}
@Test
public void shouldBindWithLogErrorHandlerWithParameters() throws Exception {
Bind command = createCommand("timer", "log");
command.errorHandler = "log";
command.properties = new String[] {
"error-handler.maximumRedeliveries=3",
"error-handler.redeliveryDelay=2000"
};
command.doCall();
String output = printer.getOutput();
Assertions.assertEquals("""
apiVersion: camel.apache.org/v1
kind: Pipe
metadata:
name: timer-to-log
spec:
source:
ref:
kind: Kamelet
apiVersion: camel.apache.org/v1
name: timer-source
properties:
message: "hello world"
sink:
ref:
kind: Kamelet
apiVersion: camel.apache.org/v1
name: log-sink
#properties:
#key: "value"
errorHandler:
log:
parameters:
redeliveryDelay: 2000
maximumRedeliveries: 3
""".trim(), output);
}
@Test
public void shouldBindWithNoErrorHandler() throws Exception {
Bind command = createCommand("timer", "log");
command.errorHandler = "none";
command.doCall();
String output = printer.getOutput();
Assertions.assertEquals("""
apiVersion: camel.apache.org/v1
kind: Pipe
metadata:
name: timer-to-log
spec:
source:
ref:
kind: Kamelet
apiVersion: camel.apache.org/v1
name: timer-source
properties:
message: "hello world"
sink:
ref:
kind: Kamelet
apiVersion: camel.apache.org/v1
name: log-sink
#properties:
#key: "value"
errorHandler:
none: {}
""".trim(), output);
}
@Test
public void shouldSupportJsonOutput() throws Exception {
Bind command = createCommand("timer", "log");
command.output = "json";
command.doCall();
String output = printer.getOutput();
Assertions.assertEquals("""
{
"apiVersion": "camel.apache.org/v1",
"kind": "Pipe",
"metadata": {
"name": "timer-to-log"
},
"spec": {
"source": {
"ref": {
"kind": "Kamelet",
"apiVersion": "camel.apache.org/v1",
"name": "timer-source"
},
"properties": {
"message": "hello world"
}
},
"sink": {
"ref": {
"kind": "Kamelet",
"apiVersion": "camel.apache.org/v1",
"name": "log-sink"
}
}
}
}
""".trim(), output);
}
@Test
public void shouldHandleUnsupportedOutputFormat() throws Exception {
Bind command = createCommand("timer", "log");
command.output = "wrong";
Assertions.assertEquals(-1, command.doCall());
Assertions.assertEquals("ERROR: Unsupported output format 'wrong' (supported: file, yaml, json)", printer.getOutput());
}
private Bind createCommand(String source, String sink) {
Bind command = new Bind(new CamelJBangMain().withPrinter(printer));
String sourceName;
String sourceUri;
if (source.contains(":")) {
sourceName = StringHelper.before(source, ":");
sourceUri = source;
} else {
sourceName = source;
sourceUri = source + "-source";
}
String sinkName;
String sinkUri;
if (sink.contains(":")) {
sinkName = StringHelper.before(sink, ":");
sinkUri = sink;
} else {
sinkName = sink;
sinkUri = sink + "-sink";
}
command.file = sourceName + "-to-" + sinkName + ".yaml";
command.source = sourceUri;
command.sink = sinkUri;
command.output = "yaml";
return command;
}
}
| BindTest |
java | alibaba__druid | core/src/main/java/com/alibaba/druid/sql/ast/statement/SQLPrimaryKeyImpl.java | {
"start": 722,
"end": 2085
} | class ____ extends SQLUnique implements SQLPrimaryKey, SQLTableConstraint {
protected boolean disableNovalidate;
protected boolean clustered; // sql server
protected boolean notEnforced; // bigquery
public SQLPrimaryKeyImpl() {
}
@Override
protected void accept0(SQLASTVisitor visitor) {
if (visitor.visit(this)) {
acceptChild(visitor, this.getName());
acceptChild(visitor, this.getColumns());
}
visitor.endVisit(this);
}
public SQLPrimaryKeyImpl clone() {
SQLPrimaryKeyImpl x = new SQLPrimaryKeyImpl();
cloneTo(x);
return x;
}
public void cloneTo(SQLPrimaryKeyImpl x) {
super.cloneTo(x);
x.disableNovalidate = disableNovalidate;
x.clustered = clustered;
}
public boolean isDisableNovalidate() {
return disableNovalidate;
}
public void setDisableNovalidate(boolean disableNovalidate) {
this.disableNovalidate = disableNovalidate;
}
public boolean isClustered() {
return clustered;
}
public void setClustered(boolean clustered) {
this.clustered = clustered;
}
public boolean isNotEnforced() {
return notEnforced;
}
public void setNotEnforced(boolean notEnforced) {
this.notEnforced = notEnforced;
}
}
| SQLPrimaryKeyImpl |
java | elastic__elasticsearch | x-pack/plugin/ml/qa/native-multi-node-tests/src/javaRestTest/java/org/elasticsearch/xpack/ml/integration/ClassificationEvaluationIT.java | {
"start": 2259,
"end": 39439
} | class ____ extends MlNativeDataFrameAnalyticsIntegTestCase {
static final String ANIMALS_DATA_INDEX = "test-evaluate-animals-index";
static final String ANIMAL_NAME_KEYWORD_FIELD = "animal_name_keyword";
static final String ANIMAL_NAME_PREDICTION_KEYWORD_FIELD = "animal_name_keyword_prediction";
static final String ANIMAL_NAME_PREDICTION_PROB_FIELD = "animal_name_prediction_prob";
static final String NO_LEGS_KEYWORD_FIELD = "no_legs_keyword";
static final String NO_LEGS_INTEGER_FIELD = "no_legs_integer";
static final String NO_LEGS_PREDICTION_INTEGER_FIELD = "no_legs_integer_prediction";
static final String IS_PREDATOR_KEYWORD_FIELD = "predator_keyword";
static final String IS_PREDATOR_BOOLEAN_FIELD = "predator_boolean";
static final String IS_PREDATOR_PREDICTION_BOOLEAN_FIELD = "predator_boolean_prediction";
static final String IS_PREDATOR_PREDICTION_PROBABILITY_FIELD = "predator_prediction_probability";
static final String ML_TOP_CLASSES_FIELD = "ml_results";
@Before
public void setup() {
createAnimalsIndex(ANIMALS_DATA_INDEX);
indexAnimalsData(ANIMALS_DATA_INDEX);
}
@After
public void cleanup() {
cleanUp();
updateClusterSettings(Settings.builder().putNull("search.max_buckets"));
}
public void testEvaluate_DefaultMetrics() {
EvaluateDataFrameAction.Response evaluateDataFrameResponse = evaluateDataFrame(
ANIMALS_DATA_INDEX,
new Classification(ANIMAL_NAME_KEYWORD_FIELD, ANIMAL_NAME_PREDICTION_KEYWORD_FIELD, null, null)
);
assertThat(evaluateDataFrameResponse.getEvaluationName(), equalTo(Classification.NAME.getPreferredName()));
assertThat(
evaluateDataFrameResponse.getMetrics().stream().map(EvaluationMetricResult::getMetricName).collect(toList()),
containsInAnyOrder(
MulticlassConfusionMatrix.NAME.getPreferredName(),
Accuracy.NAME.getPreferredName(),
Precision.NAME.getPreferredName(),
Recall.NAME.getPreferredName()
)
);
}
public void testEvaluate_AllMetrics() {
EvaluateDataFrameAction.Response evaluateDataFrameResponse = evaluateDataFrame(
ANIMALS_DATA_INDEX,
new Classification(
ANIMAL_NAME_KEYWORD_FIELD,
ANIMAL_NAME_PREDICTION_KEYWORD_FIELD,
null,
List.of(new Accuracy(), new MulticlassConfusionMatrix(), new Precision(), new Recall())
)
);
assertThat(evaluateDataFrameResponse.getEvaluationName(), equalTo(Classification.NAME.getPreferredName()));
assertThat(
evaluateDataFrameResponse.getMetrics().stream().map(EvaluationMetricResult::getMetricName).collect(toList()),
contains(
Accuracy.NAME.getPreferredName(),
MulticlassConfusionMatrix.NAME.getPreferredName(),
Precision.NAME.getPreferredName(),
Recall.NAME.getPreferredName()
)
);
}
public void testEvaluate_AllMetrics_KeywordField_CaseSensitivity() {
String indexName = "some-index";
String actualField = "fieldA";
String predictedField = "fieldB";
client().admin().indices().prepareCreate(indexName).setMapping(actualField, "type=keyword", predictedField, "type=keyword").get();
prepareIndex(indexName).setRefreshPolicy(WriteRequest.RefreshPolicy.IMMEDIATE)
.setSource(actualField, "crocodile", predictedField, "cRoCoDiLe")
.get();
EvaluateDataFrameAction.Response evaluateDataFrameResponse = evaluateDataFrame(
indexName,
new Classification(
actualField,
predictedField,
null,
List.of(new Accuracy(), new MulticlassConfusionMatrix(), new Precision(), new Recall())
)
);
Accuracy.Result accuracyResult = (Accuracy.Result) evaluateDataFrameResponse.getMetrics().get(0);
assertThat(accuracyResult.getClasses(), contains(new PerClassSingleValue("crocodile", 0.0)));
assertThat(accuracyResult.getOverallAccuracy(), equalTo(0.0));
MulticlassConfusionMatrix.Result confusionMatrixResult = (MulticlassConfusionMatrix.Result) evaluateDataFrameResponse.getMetrics()
.get(1);
assertThat(
confusionMatrixResult.getConfusionMatrix(),
equalTo(
List.of(
new MulticlassConfusionMatrix.ActualClass(
"crocodile",
1,
List.of(new MulticlassConfusionMatrix.PredictedClass("crocodile", 0L)),
1
)
)
)
);
Precision.Result precisionResult = (Precision.Result) evaluateDataFrameResponse.getMetrics().get(2);
assertThat(precisionResult.getClasses(), empty());
assertThat(precisionResult.getAvgPrecision(), is(notANumber()));
Recall.Result recallResult = (Recall.Result) evaluateDataFrameResponse.getMetrics().get(3);
assertThat(recallResult.getClasses(), contains(new PerClassSingleValue("crocodile", 0.0)));
assertThat(recallResult.getAvgRecall(), equalTo(0.0));
}
private AucRoc.Result evaluateAucRoc(boolean includeCurve) {
EvaluateDataFrameAction.Response evaluateDataFrameResponse = evaluateDataFrame(
ANIMALS_DATA_INDEX,
new Classification(ANIMAL_NAME_KEYWORD_FIELD, null, ML_TOP_CLASSES_FIELD, List.of(new AucRoc(includeCurve, "cat")))
);
assertThat(evaluateDataFrameResponse.getEvaluationName(), equalTo(Classification.NAME.getPreferredName()));
assertThat(evaluateDataFrameResponse.getMetrics(), hasSize(1));
AucRoc.Result aucrocResult = (AucRoc.Result) evaluateDataFrameResponse.getMetrics().get(0);
assertThat(aucrocResult.getMetricName(), equalTo(AucRoc.NAME.getPreferredName()));
return aucrocResult;
}
public void testEvaluate_AucRoc_DoNotIncludeCurve() {
AucRoc.Result aucrocResult = evaluateAucRoc(false);
assertThat(aucrocResult.getValue(), is(closeTo(0.5, 0.0001)));
assertThat(aucrocResult.getCurve(), hasSize(0));
}
public void testEvaluate_AucRoc_IncludeCurve() {
AucRoc.Result aucrocResult = evaluateAucRoc(true);
assertThat(aucrocResult.getValue(), is(closeTo(0.5, 0.0001)));
assertThat(aucrocResult.getCurve(), hasSize(greaterThan(0)));
}
private Accuracy.Result evaluateAccuracy(String actualField, String predictedField) {
EvaluateDataFrameAction.Response evaluateDataFrameResponse = evaluateDataFrame(
ANIMALS_DATA_INDEX,
new Classification(actualField, predictedField, null, List.of(new Accuracy()))
);
assertThat(evaluateDataFrameResponse.getEvaluationName(), equalTo(Classification.NAME.getPreferredName()));
assertThat(evaluateDataFrameResponse.getMetrics(), hasSize(1));
Accuracy.Result accuracyResult = (Accuracy.Result) evaluateDataFrameResponse.getMetrics().get(0);
assertThat(accuracyResult.getMetricName(), equalTo(Accuracy.NAME.getPreferredName()));
return accuracyResult;
}
public void testEvaluate_Accuracy_KeywordField() {
List<PerClassSingleValue> expectedPerClassResults = List.of(
new PerClassSingleValue("ant", 47.0 / 75),
new PerClassSingleValue("cat", 47.0 / 75),
new PerClassSingleValue("dog", 47.0 / 75),
new PerClassSingleValue("fox", 47.0 / 75),
new PerClassSingleValue("mouse", 47.0 / 75)
);
double expectedOverallAccuracy = 5.0 / 75;
Accuracy.Result accuracyResult = evaluateAccuracy(ANIMAL_NAME_KEYWORD_FIELD, ANIMAL_NAME_PREDICTION_KEYWORD_FIELD);
assertThat(accuracyResult.getClasses(), equalTo(expectedPerClassResults));
assertThat(accuracyResult.getOverallAccuracy(), equalTo(expectedOverallAccuracy));
// Actual and predicted fields are swapped but this does not alter the result (accuracy is symmetric)
accuracyResult = evaluateAccuracy(ANIMAL_NAME_PREDICTION_KEYWORD_FIELD, ANIMAL_NAME_KEYWORD_FIELD);
assertThat(accuracyResult.getClasses(), equalTo(expectedPerClassResults));
assertThat(accuracyResult.getOverallAccuracy(), equalTo(expectedOverallAccuracy));
}
public void testEvaluate_Accuracy_IntegerField() {
List<PerClassSingleValue> expectedPerClassResults = List.of(
new PerClassSingleValue("1", 57.0 / 75),
new PerClassSingleValue("2", 54.0 / 75),
new PerClassSingleValue("3", 51.0 / 75),
new PerClassSingleValue("4", 48.0 / 75),
new PerClassSingleValue("5", 45.0 / 75)
);
double expectedOverallAccuracy = 15.0 / 75;
Accuracy.Result accuracyResult = evaluateAccuracy(NO_LEGS_INTEGER_FIELD, NO_LEGS_PREDICTION_INTEGER_FIELD);
assertThat(accuracyResult.getClasses(), equalTo(expectedPerClassResults));
assertThat(accuracyResult.getOverallAccuracy(), equalTo(expectedOverallAccuracy));
// Actual and predicted fields are swapped but this does not alter the result (accuracy is symmetric)
accuracyResult = evaluateAccuracy(NO_LEGS_PREDICTION_INTEGER_FIELD, NO_LEGS_INTEGER_FIELD);
assertThat(accuracyResult.getClasses(), equalTo(expectedPerClassResults));
assertThat(accuracyResult.getOverallAccuracy(), equalTo(expectedOverallAccuracy));
// Actual and predicted fields are of different types but the values are matched correctly
accuracyResult = evaluateAccuracy(NO_LEGS_KEYWORD_FIELD, NO_LEGS_PREDICTION_INTEGER_FIELD);
assertThat(accuracyResult.getClasses(), equalTo(expectedPerClassResults));
assertThat(accuracyResult.getOverallAccuracy(), equalTo(expectedOverallAccuracy));
// Actual and predicted fields are of different types but the values are matched correctly
accuracyResult = evaluateAccuracy(NO_LEGS_PREDICTION_INTEGER_FIELD, NO_LEGS_KEYWORD_FIELD);
assertThat(accuracyResult.getClasses(), equalTo(expectedPerClassResults));
assertThat(accuracyResult.getOverallAccuracy(), equalTo(expectedOverallAccuracy));
}
public void testEvaluate_Accuracy_BooleanField() {
List<PerClassSingleValue> expectedPerClassResults = List.of(
new PerClassSingleValue("false", 18.0 / 30),
new PerClassSingleValue("true", 27.0 / 45)
);
double expectedOverallAccuracy = 45.0 / 75;
Accuracy.Result accuracyResult = evaluateAccuracy(IS_PREDATOR_BOOLEAN_FIELD, IS_PREDATOR_PREDICTION_BOOLEAN_FIELD);
assertThat(accuracyResult.getClasses(), equalTo(expectedPerClassResults));
assertThat(accuracyResult.getOverallAccuracy(), equalTo(expectedOverallAccuracy));
// Actual and predicted fields are swapped but this does not alter the result (accuracy is symmetric)
accuracyResult = evaluateAccuracy(IS_PREDATOR_PREDICTION_BOOLEAN_FIELD, IS_PREDATOR_BOOLEAN_FIELD);
assertThat(accuracyResult.getClasses(), equalTo(expectedPerClassResults));
assertThat(accuracyResult.getOverallAccuracy(), equalTo(expectedOverallAccuracy));
// Actual and predicted fields are of different types but the values are matched correctly
accuracyResult = evaluateAccuracy(IS_PREDATOR_KEYWORD_FIELD, IS_PREDATOR_PREDICTION_BOOLEAN_FIELD);
assertThat(accuracyResult.getClasses(), equalTo(expectedPerClassResults));
assertThat(accuracyResult.getOverallAccuracy(), equalTo(expectedOverallAccuracy));
// Actual and predicted fields are of different types but the values are matched correctly
accuracyResult = evaluateAccuracy(IS_PREDATOR_PREDICTION_BOOLEAN_FIELD, IS_PREDATOR_KEYWORD_FIELD);
assertThat(accuracyResult.getClasses(), equalTo(expectedPerClassResults));
assertThat(accuracyResult.getOverallAccuracy(), equalTo(expectedOverallAccuracy));
}
public void testEvaluate_Accuracy_FieldTypeMismatch() {
{
// When actual and predicted fields have different types, the sets of classes are disjoint
List<PerClassSingleValue> expectedPerClassResults = List.of(
new PerClassSingleValue("1", 0.8),
new PerClassSingleValue("2", 0.8),
new PerClassSingleValue("3", 0.8),
new PerClassSingleValue("4", 0.8),
new PerClassSingleValue("5", 0.8)
);
double expectedOverallAccuracy = 0.0;
Accuracy.Result accuracyResult = evaluateAccuracy(NO_LEGS_INTEGER_FIELD, IS_PREDATOR_BOOLEAN_FIELD);
assertThat(accuracyResult.getClasses(), equalTo(expectedPerClassResults));
assertThat(accuracyResult.getOverallAccuracy(), equalTo(expectedOverallAccuracy));
}
{
// When actual and predicted fields have different types, the sets of classes are disjoint
List<PerClassSingleValue> expectedPerClassResults = List.of(
new PerClassSingleValue("false", 0.6),
new PerClassSingleValue("true", 0.4)
);
double expectedOverallAccuracy = 0.0;
Accuracy.Result accuracyResult = evaluateAccuracy(IS_PREDATOR_BOOLEAN_FIELD, NO_LEGS_INTEGER_FIELD);
assertThat(accuracyResult.getClasses(), equalTo(expectedPerClassResults));
assertThat(accuracyResult.getOverallAccuracy(), equalTo(expectedOverallAccuracy));
}
}
private Precision.Result evaluatePrecision(String actualField, String predictedField) {
EvaluateDataFrameAction.Response evaluateDataFrameResponse = evaluateDataFrame(
ANIMALS_DATA_INDEX,
new Classification(actualField, predictedField, null, List.of(new Precision()))
);
assertThat(evaluateDataFrameResponse.getEvaluationName(), equalTo(Classification.NAME.getPreferredName()));
assertThat(evaluateDataFrameResponse.getMetrics(), hasSize(1));
Precision.Result precisionResult = (Precision.Result) evaluateDataFrameResponse.getMetrics().get(0);
assertThat(precisionResult.getMetricName(), equalTo(Precision.NAME.getPreferredName()));
return precisionResult;
}
public void testEvaluate_Precision_KeywordField() {
List<PerClassSingleValue> expectedPerClassResults = List.of(
new PerClassSingleValue("ant", 1.0 / 15),
new PerClassSingleValue("cat", 1.0 / 15),
new PerClassSingleValue("dog", 1.0 / 15),
new PerClassSingleValue("fox", 1.0 / 15),
new PerClassSingleValue("mouse", 1.0 / 15)
);
double expectedAvgPrecision = 5.0 / 75;
Precision.Result precisionResult = evaluatePrecision(ANIMAL_NAME_KEYWORD_FIELD, ANIMAL_NAME_PREDICTION_KEYWORD_FIELD);
assertThat(precisionResult.getClasses(), equalTo(expectedPerClassResults));
assertThat(precisionResult.getAvgPrecision(), equalTo(expectedAvgPrecision));
evaluatePrecision(ANIMAL_NAME_PREDICTION_KEYWORD_FIELD, ANIMAL_NAME_KEYWORD_FIELD);
}
public void testEvaluate_Precision_IntegerField() {
List<PerClassSingleValue> expectedPerClassResults = List.of(
new PerClassSingleValue("1", 0.2),
new PerClassSingleValue("2", 0.2),
new PerClassSingleValue("3", 0.2),
new PerClassSingleValue("4", 0.2),
new PerClassSingleValue("5", 0.2)
);
double expectedAvgPrecision = 0.2;
Precision.Result precisionResult = evaluatePrecision(NO_LEGS_INTEGER_FIELD, NO_LEGS_PREDICTION_INTEGER_FIELD);
assertThat(precisionResult.getClasses(), equalTo(expectedPerClassResults));
assertThat(precisionResult.getAvgPrecision(), equalTo(expectedAvgPrecision));
// Actual and predicted fields are of different types but the values are matched correctly
precisionResult = evaluatePrecision(NO_LEGS_KEYWORD_FIELD, NO_LEGS_PREDICTION_INTEGER_FIELD);
assertThat(precisionResult.getClasses(), equalTo(expectedPerClassResults));
assertThat(precisionResult.getAvgPrecision(), equalTo(expectedAvgPrecision));
evaluatePrecision(NO_LEGS_PREDICTION_INTEGER_FIELD, NO_LEGS_INTEGER_FIELD);
evaluatePrecision(NO_LEGS_PREDICTION_INTEGER_FIELD, NO_LEGS_KEYWORD_FIELD);
}
public void testEvaluate_Precision_BooleanField() {
List<PerClassSingleValue> expectedPerClassResults = List.of(
new PerClassSingleValue("false", 0.5),
new PerClassSingleValue("true", 9.0 / 13)
);
double expectedAvgPrecision = 31.0 / 52;
Precision.Result precisionResult = evaluatePrecision(IS_PREDATOR_BOOLEAN_FIELD, IS_PREDATOR_PREDICTION_BOOLEAN_FIELD);
assertThat(precisionResult.getClasses(), equalTo(expectedPerClassResults));
assertThat(precisionResult.getAvgPrecision(), equalTo(expectedAvgPrecision));
// Actual and predicted fields are of different types but the values are matched correctly
precisionResult = evaluatePrecision(IS_PREDATOR_KEYWORD_FIELD, IS_PREDATOR_PREDICTION_BOOLEAN_FIELD);
assertThat(precisionResult.getClasses(), equalTo(expectedPerClassResults));
assertThat(precisionResult.getAvgPrecision(), equalTo(expectedAvgPrecision));
evaluatePrecision(IS_PREDATOR_PREDICTION_BOOLEAN_FIELD, IS_PREDATOR_BOOLEAN_FIELD);
evaluatePrecision(IS_PREDATOR_PREDICTION_BOOLEAN_FIELD, IS_PREDATOR_KEYWORD_FIELD);
}
public void testEvaluate_Precision_FieldTypeMismatch() {
{
Precision.Result precisionResult = evaluatePrecision(NO_LEGS_INTEGER_FIELD, IS_PREDATOR_BOOLEAN_FIELD);
// When actual and predicted fields have different types, the sets of classes are disjoint, hence empty results here
assertThat(precisionResult.getClasses(), empty());
assertThat(precisionResult.getAvgPrecision(), is(notANumber()));
}
{
Precision.Result precisionResult = evaluatePrecision(IS_PREDATOR_BOOLEAN_FIELD, NO_LEGS_INTEGER_FIELD);
// When actual and predicted fields have different types, the sets of classes are disjoint, hence empty results here
assertThat(precisionResult.getClasses(), empty());
assertThat(precisionResult.getAvgPrecision(), is(notANumber()));
}
}
public void testEvaluate_Precision_CardinalityTooHigh() {
indexDistinctAnimals(ANIMALS_DATA_INDEX, 1001);
ElasticsearchStatusException e = expectThrows(
ElasticsearchStatusException.class,
() -> evaluateDataFrame(
ANIMALS_DATA_INDEX,
new Classification(ANIMAL_NAME_KEYWORD_FIELD, ANIMAL_NAME_PREDICTION_KEYWORD_FIELD, null, List.of(new Precision()))
)
);
assertThat(e.getMessage(), containsString("Cardinality of field [animal_name_keyword] is too high"));
}
private Recall.Result evaluateRecall(String actualField, String predictedField) {
EvaluateDataFrameAction.Response evaluateDataFrameResponse = evaluateDataFrame(
ANIMALS_DATA_INDEX,
new Classification(actualField, predictedField, null, List.of(new Recall()))
);
assertThat(evaluateDataFrameResponse.getEvaluationName(), equalTo(Classification.NAME.getPreferredName()));
assertThat(evaluateDataFrameResponse.getMetrics(), hasSize(1));
Recall.Result recallResult = (Recall.Result) evaluateDataFrameResponse.getMetrics().get(0);
assertThat(recallResult.getMetricName(), equalTo(Recall.NAME.getPreferredName()));
return recallResult;
}
public void testEvaluate_Recall_KeywordField() {
List<PerClassSingleValue> expectedPerClassResults = List.of(
new PerClassSingleValue("ant", 1.0 / 15),
new PerClassSingleValue("cat", 1.0 / 15),
new PerClassSingleValue("dog", 1.0 / 15),
new PerClassSingleValue("fox", 1.0 / 15),
new PerClassSingleValue("mouse", 1.0 / 15)
);
double expectedAvgRecall = 5.0 / 75;
Recall.Result recallResult = evaluateRecall(ANIMAL_NAME_KEYWORD_FIELD, ANIMAL_NAME_PREDICTION_KEYWORD_FIELD);
assertThat(recallResult.getClasses(), equalTo(expectedPerClassResults));
assertThat(recallResult.getAvgRecall(), equalTo(expectedAvgRecall));
evaluateRecall(ANIMAL_NAME_PREDICTION_KEYWORD_FIELD, ANIMAL_NAME_KEYWORD_FIELD);
}
public void testEvaluate_Recall_IntegerField() {
List<PerClassSingleValue> expectedPerClassResults = List.of(
new PerClassSingleValue("1", 1.0 / 15),
new PerClassSingleValue("2", 2.0 / 15),
new PerClassSingleValue("3", 3.0 / 15),
new PerClassSingleValue("4", 4.0 / 15),
new PerClassSingleValue("5", 5.0 / 15)
);
double expectedAvgRecall = 3.0 / 15;
Recall.Result recallResult = evaluateRecall(NO_LEGS_INTEGER_FIELD, NO_LEGS_PREDICTION_INTEGER_FIELD);
assertThat(recallResult.getClasses(), equalTo(expectedPerClassResults));
assertThat(recallResult.getAvgRecall(), equalTo(expectedAvgRecall));
// Actual and predicted fields are of different types but the values are matched correctly
recallResult = evaluateRecall(NO_LEGS_KEYWORD_FIELD, NO_LEGS_PREDICTION_INTEGER_FIELD);
assertThat(recallResult.getClasses(), equalTo(expectedPerClassResults));
assertThat(recallResult.getAvgRecall(), equalTo(expectedAvgRecall));
evaluateRecall(NO_LEGS_PREDICTION_INTEGER_FIELD, NO_LEGS_INTEGER_FIELD);
evaluateRecall(NO_LEGS_PREDICTION_INTEGER_FIELD, NO_LEGS_KEYWORD_FIELD);
}
public void testEvaluate_Recall_BooleanField() {
List<PerClassSingleValue> expectedPerClassResults = List.of(
new PerClassSingleValue("true", 0.6),
new PerClassSingleValue("false", 0.6)
);
double expectedAvgRecall = 0.6;
Recall.Result recallResult = evaluateRecall(IS_PREDATOR_BOOLEAN_FIELD, IS_PREDATOR_PREDICTION_BOOLEAN_FIELD);
assertThat(recallResult.getClasses(), equalTo(expectedPerClassResults));
assertThat(recallResult.getAvgRecall(), equalTo(expectedAvgRecall));
// Actual and predicted fields are of different types but the values are matched correctly
recallResult = evaluateRecall(IS_PREDATOR_KEYWORD_FIELD, IS_PREDATOR_PREDICTION_BOOLEAN_FIELD);
assertThat(recallResult.getClasses(), equalTo(expectedPerClassResults));
assertThat(recallResult.getAvgRecall(), equalTo(expectedAvgRecall));
evaluateRecall(IS_PREDATOR_PREDICTION_BOOLEAN_FIELD, IS_PREDATOR_BOOLEAN_FIELD);
evaluateRecall(IS_PREDATOR_PREDICTION_BOOLEAN_FIELD, IS_PREDATOR_KEYWORD_FIELD);
}
public void testEvaluate_Recall_FieldTypeMismatch() {
{
// When actual and predicted fields have different types, the sets of classes are disjoint, hence 0.0 results here
List<PerClassSingleValue> expectedPerClassResults = List.of(
new PerClassSingleValue("1", 0.0),
new PerClassSingleValue("2", 0.0),
new PerClassSingleValue("3", 0.0),
new PerClassSingleValue("4", 0.0),
new PerClassSingleValue("5", 0.0)
);
double expectedAvgRecall = 0.0;
Recall.Result recallResult = evaluateRecall(NO_LEGS_INTEGER_FIELD, IS_PREDATOR_BOOLEAN_FIELD);
assertThat(recallResult.getClasses(), equalTo(expectedPerClassResults));
assertThat(recallResult.getAvgRecall(), equalTo(expectedAvgRecall));
}
{
// When actual and predicted fields have different types, the sets of classes are disjoint, hence 0.0 results here
List<PerClassSingleValue> expectedPerClassResults = List.of(
new PerClassSingleValue("true", 0.0),
new PerClassSingleValue("false", 0.0)
);
double expectedAvgRecall = 0.0;
Recall.Result recallResult = evaluateRecall(IS_PREDATOR_BOOLEAN_FIELD, NO_LEGS_INTEGER_FIELD);
assertThat(recallResult.getClasses(), equalTo(expectedPerClassResults));
assertThat(recallResult.getAvgRecall(), equalTo(expectedAvgRecall));
}
}
public void testEvaluate_Recall_CardinalityTooHigh() {
indexDistinctAnimals(ANIMALS_DATA_INDEX, 1001);
ElasticsearchStatusException e = expectThrows(
ElasticsearchStatusException.class,
() -> evaluateDataFrame(
ANIMALS_DATA_INDEX,
new Classification(ANIMAL_NAME_KEYWORD_FIELD, ANIMAL_NAME_PREDICTION_KEYWORD_FIELD, null, List.of(new Recall()))
)
);
assertThat(e.getMessage(), containsString("Cardinality of field [animal_name_keyword] is too high"));
}
private void evaluateMulticlassConfusionMatrix() {
EvaluateDataFrameAction.Response evaluateDataFrameResponse = evaluateDataFrame(
ANIMALS_DATA_INDEX,
new Classification(
ANIMAL_NAME_KEYWORD_FIELD,
ANIMAL_NAME_PREDICTION_KEYWORD_FIELD,
null,
List.of(new MulticlassConfusionMatrix())
)
);
assertThat(evaluateDataFrameResponse.getEvaluationName(), equalTo(Classification.NAME.getPreferredName()));
assertThat(evaluateDataFrameResponse.getMetrics(), hasSize(1));
MulticlassConfusionMatrix.Result confusionMatrixResult = (MulticlassConfusionMatrix.Result) evaluateDataFrameResponse.getMetrics()
.get(0);
assertThat(confusionMatrixResult.getMetricName(), equalTo(MulticlassConfusionMatrix.NAME.getPreferredName()));
assertThat(
confusionMatrixResult.getConfusionMatrix(),
equalTo(
List.of(
new MulticlassConfusionMatrix.ActualClass(
"ant",
15,
List.of(
new MulticlassConfusionMatrix.PredictedClass("ant", 1L),
new MulticlassConfusionMatrix.PredictedClass("cat", 4L),
new MulticlassConfusionMatrix.PredictedClass("dog", 3L),
new MulticlassConfusionMatrix.PredictedClass("fox", 2L),
new MulticlassConfusionMatrix.PredictedClass("mouse", 5L)
),
0
),
new MulticlassConfusionMatrix.ActualClass(
"cat",
15,
List.of(
new MulticlassConfusionMatrix.PredictedClass("ant", 3L),
new MulticlassConfusionMatrix.PredictedClass("cat", 1L),
new MulticlassConfusionMatrix.PredictedClass("dog", 5L),
new MulticlassConfusionMatrix.PredictedClass("fox", 4L),
new MulticlassConfusionMatrix.PredictedClass("mouse", 2L)
),
0
),
new MulticlassConfusionMatrix.ActualClass(
"dog",
15,
List.of(
new MulticlassConfusionMatrix.PredictedClass("ant", 4L),
new MulticlassConfusionMatrix.PredictedClass("cat", 2L),
new MulticlassConfusionMatrix.PredictedClass("dog", 1L),
new MulticlassConfusionMatrix.PredictedClass("fox", 5L),
new MulticlassConfusionMatrix.PredictedClass("mouse", 3L)
),
0
),
new MulticlassConfusionMatrix.ActualClass(
"fox",
15,
List.of(
new MulticlassConfusionMatrix.PredictedClass("ant", 5L),
new MulticlassConfusionMatrix.PredictedClass("cat", 3L),
new MulticlassConfusionMatrix.PredictedClass("dog", 2L),
new MulticlassConfusionMatrix.PredictedClass("fox", 1L),
new MulticlassConfusionMatrix.PredictedClass("mouse", 4L)
),
0
),
new MulticlassConfusionMatrix.ActualClass(
"mouse",
15,
List.of(
new MulticlassConfusionMatrix.PredictedClass("ant", 2L),
new MulticlassConfusionMatrix.PredictedClass("cat", 5L),
new MulticlassConfusionMatrix.PredictedClass("dog", 4L),
new MulticlassConfusionMatrix.PredictedClass("fox", 3L),
new MulticlassConfusionMatrix.PredictedClass("mouse", 1L)
),
0
)
)
)
);
assertThat(confusionMatrixResult.getOtherActualClassCount(), equalTo(0L));
}
public void testEvaluate_ConfusionMatrixMetricWithDefaultSize() {
evaluateMulticlassConfusionMatrix();
updateClusterSettings(Settings.builder().put("search.max_buckets", 20));
evaluateMulticlassConfusionMatrix();
updateClusterSettings(Settings.builder().put("search.max_buckets", 7));
evaluateMulticlassConfusionMatrix();
updateClusterSettings(Settings.builder().put("search.max_buckets", 6));
ElasticsearchException e = expectThrows(ElasticsearchException.class, this::evaluateMulticlassConfusionMatrix);
assertThat(e.getCause(), is(instanceOf(TooManyBucketsException.class)));
TooManyBucketsException tmbe = (TooManyBucketsException) e.getCause();
assertThat(tmbe.getMaxBuckets(), equalTo(6));
}
public void testEvaluate_ConfusionMatrixMetricWithUserProvidedSize() {
EvaluateDataFrameAction.Response evaluateDataFrameResponse = evaluateDataFrame(
ANIMALS_DATA_INDEX,
new Classification(
ANIMAL_NAME_KEYWORD_FIELD,
ANIMAL_NAME_PREDICTION_KEYWORD_FIELD,
null,
List.of(new MulticlassConfusionMatrix(3, null))
)
);
assertThat(evaluateDataFrameResponse.getEvaluationName(), equalTo(Classification.NAME.getPreferredName()));
assertThat(evaluateDataFrameResponse.getMetrics(), hasSize(1));
MulticlassConfusionMatrix.Result confusionMatrixResult = (MulticlassConfusionMatrix.Result) evaluateDataFrameResponse.getMetrics()
.get(0);
assertThat(confusionMatrixResult.getMetricName(), equalTo(MulticlassConfusionMatrix.NAME.getPreferredName()));
assertThat(
confusionMatrixResult.getConfusionMatrix(),
equalTo(
List.of(
new MulticlassConfusionMatrix.ActualClass(
"ant",
15,
List.of(
new MulticlassConfusionMatrix.PredictedClass("ant", 1L),
new MulticlassConfusionMatrix.PredictedClass("cat", 4L),
new MulticlassConfusionMatrix.PredictedClass("dog", 3L)
),
7
),
new MulticlassConfusionMatrix.ActualClass(
"cat",
15,
List.of(
new MulticlassConfusionMatrix.PredictedClass("ant", 3L),
new MulticlassConfusionMatrix.PredictedClass("cat", 1L),
new MulticlassConfusionMatrix.PredictedClass("dog", 5L)
),
6
),
new MulticlassConfusionMatrix.ActualClass(
"dog",
15,
List.of(
new MulticlassConfusionMatrix.PredictedClass("ant", 4L),
new MulticlassConfusionMatrix.PredictedClass("cat", 2L),
new MulticlassConfusionMatrix.PredictedClass("dog", 1L)
),
8
)
)
)
);
assertThat(confusionMatrixResult.getOtherActualClassCount(), equalTo(2L));
}
static void createAnimalsIndex(String indexName) {
indicesAdmin().prepareCreate(indexName)
.setMapping(
ANIMAL_NAME_KEYWORD_FIELD,
"type=keyword",
ANIMAL_NAME_PREDICTION_KEYWORD_FIELD,
"type=keyword",
NO_LEGS_KEYWORD_FIELD,
"type=keyword",
NO_LEGS_INTEGER_FIELD,
"type=integer",
NO_LEGS_PREDICTION_INTEGER_FIELD,
"type=integer",
IS_PREDATOR_KEYWORD_FIELD,
"type=keyword",
IS_PREDATOR_BOOLEAN_FIELD,
"type=boolean",
IS_PREDATOR_PREDICTION_BOOLEAN_FIELD,
"type=boolean",
IS_PREDATOR_PREDICTION_PROBABILITY_FIELD,
"type=double",
ML_TOP_CLASSES_FIELD,
"type=nested"
)
.get();
}
static void indexAnimalsData(String indexName) {
List<String> animalNames = List.of("dog", "cat", "mouse", "ant", "fox");
BulkRequestBuilder bulkRequestBuilder = client().prepareBulk().setRefreshPolicy(WriteRequest.RefreshPolicy.IMMEDIATE);
for (int i = 0; i < animalNames.size(); i++) {
for (int j = 0; j < animalNames.size(); j++) {
for (int k = 0; k < j + 1; k++) {
List<?> topClasses = IntStream.range(0, 5).mapToObj(ix -> new HashMap<String, Object>() {
{
put("class_name", animalNames.get(ix));
put("class_probability", 0.4 - 0.1 * ix);
}
}).collect(toList());
bulkRequestBuilder.add(
new IndexRequest(indexName).source(
ANIMAL_NAME_KEYWORD_FIELD,
animalNames.get(i),
ANIMAL_NAME_PREDICTION_KEYWORD_FIELD,
animalNames.get((i + j) % animalNames.size()),
ANIMAL_NAME_PREDICTION_PROB_FIELD,
animalNames.get((i + j) % animalNames.size()),
NO_LEGS_KEYWORD_FIELD,
String.valueOf(i + 1),
NO_LEGS_INTEGER_FIELD,
i + 1,
NO_LEGS_PREDICTION_INTEGER_FIELD,
j + 1,
IS_PREDATOR_KEYWORD_FIELD,
String.valueOf(i % 2 == 0),
IS_PREDATOR_BOOLEAN_FIELD,
i % 2 == 0,
IS_PREDATOR_PREDICTION_BOOLEAN_FIELD,
(i + j) % 2 == 0,
IS_PREDATOR_PREDICTION_PROBABILITY_FIELD,
i % 2 == 0 ? 1.0 - 0.1 * i : 0.1 * i,
ML_TOP_CLASSES_FIELD,
topClasses
)
);
}
}
}
BulkResponse bulkResponse = bulkRequestBuilder.get();
if (bulkResponse.hasFailures()) {
fail("Failed to index data: " + bulkResponse.buildFailureMessage());
}
}
private static void indexDistinctAnimals(String indexName, int distinctAnimalCount) {
BulkRequestBuilder bulkRequestBuilder = client().prepareBulk().setRefreshPolicy(WriteRequest.RefreshPolicy.IMMEDIATE);
for (int i = 0; i < distinctAnimalCount; i++) {
bulkRequestBuilder.add(
new IndexRequest(indexName).source(
ANIMAL_NAME_KEYWORD_FIELD,
"animal_" + i,
ANIMAL_NAME_PREDICTION_KEYWORD_FIELD,
randomAlphaOfLength(5)
)
);
}
BulkResponse bulkResponse = bulkRequestBuilder.get();
if (bulkResponse.hasFailures()) {
fail("Failed to index data: " + bulkResponse.buildFailureMessage());
}
}
@Override
boolean supportsInference() {
return true;
}
}
| ClassificationEvaluationIT |
java | apache__hadoop | hadoop-common-project/hadoop-common/src/test/java/org/apache/hadoop/util/TestDiskValidatorFactory.java | {
"start": 1135,
"end": 1182
} | class ____ test DiskValidatorFactory.
*/
public | to |
java | hibernate__hibernate-orm | hibernate-core/src/test/java/org/hibernate/orm/test/jpa/graphs/EntityGraphTest.java | {
"start": 20382,
"end": 20631
} | class ____ {
@Id
@GeneratedValue
public Integer id;
@OneToMany(mappedBy = "baz")
public Set<Foo> foos = new HashSet<>();
public Set<Foo> getFoos() {
return foos;
}
}
@Entity(name = "Book")
@Table(name = "book")
public static | Baz |
java | google__guava | guava-tests/test/com/google/common/util/concurrent/ListeningScheduledExecutorServiceTest.java | {
"start": 1329,
"end": 3663
} | class ____ extends TestCase {
private Runnable recordedCommand;
private long recordedDelay;
private long recordedInterval;
private TimeUnit recordedTimeUnit;
private final ListeningScheduledExecutorService executorService = new FakeExecutorService();
public void testScheduleRunnable() throws Exception {
Runnable command = () -> {};
ListenableScheduledFuture<?> future = executorService.schedule(command, Duration.ofSeconds(12));
assertThat(future.get()).isEqualTo("schedule");
assertThat(recordedCommand).isSameInstanceAs(command);
assertThat(recordedTimeUnit).isEqualTo(NANOSECONDS);
assertThat(Duration.ofNanos(recordedDelay)).isEqualTo(Duration.ofSeconds(12));
}
public void testScheduleCallable() throws Exception {
Callable<String> callable = () -> "hello";
ListenableScheduledFuture<String> future =
executorService.schedule(callable, Duration.ofMinutes(12));
assertThat(future.get()).isEqualTo("hello");
assertThat(recordedTimeUnit).isEqualTo(NANOSECONDS);
assertThat(Duration.ofNanos(recordedDelay)).isEqualTo(Duration.ofMinutes(12));
}
public void testScheduleAtFixedRate() throws Exception {
Runnable command = () -> {};
ListenableScheduledFuture<?> future =
executorService.scheduleAtFixedRate(command, Duration.ofDays(2), Duration.ofHours(4));
assertThat(future.get()).isEqualTo("scheduleAtFixedRate");
assertThat(recordedCommand).isSameInstanceAs(command);
assertThat(recordedTimeUnit).isEqualTo(NANOSECONDS);
assertThat(Duration.ofNanos(recordedDelay)).isEqualTo(Duration.ofDays(2));
assertThat(Duration.ofNanos(recordedInterval)).isEqualTo(Duration.ofHours(4));
}
public void testScheduleWithFixedDelay() throws Exception {
Runnable command = () -> {};
ListenableScheduledFuture<?> future =
executorService.scheduleWithFixedDelay(command, Duration.ofDays(8), Duration.ofHours(16));
assertThat(future.get()).isEqualTo("scheduleWithFixedDelay");
assertThat(recordedCommand).isSameInstanceAs(command);
assertThat(recordedTimeUnit).isEqualTo(NANOSECONDS);
assertThat(Duration.ofNanos(recordedDelay)).isEqualTo(Duration.ofDays(8));
assertThat(Duration.ofNanos(recordedInterval)).isEqualTo(Duration.ofHours(16));
}
private | ListeningScheduledExecutorServiceTest |
java | google__dagger | hilt-compiler/main/java/dagger/hilt/android/processor/internal/androidentrypoint/BroadcastReceiverGenerator.java | {
"start": 6059,
"end": 7282
} | class ____ one of its super classes implements onReceive, call super.onReceive()
findMethodBySubsignature(metadata.baseElement(), onReceiveMethod)
.filter(onReceive -> !onReceive.isAbstract())
.ifPresent(onReceive -> method.addStatement("super.onReceive(context, intent)"));
}
return method.build();
}
private Optional<XMethodElement> findMethodBySubsignature(
XTypeElement typeElement, XMethodElement method) {
String methodName = getSimpleName(method);
XType currentType = typeElement.getType();
Optional<XMethodElement> match = Optional.empty();
while (!match.isPresent() && currentType != null) {
match =
findMethodsByName(currentType.getTypeElement(), methodName).stream()
.filter(m -> XExecutableTypes.isSubsignature(m, method))
.collect(toOptional());
currentType = currentType.getTypeElement().getSuperClass();
}
return match;
}
private static ImmutableSet<XMethodElement> findMethodsByName(
XTypeElement typeElement, String name) {
return typeElement.getDeclaredMethods().stream()
.filter(m -> getSimpleName(m).contentEquals(name))
.collect(toImmutableSet());
}
}
| or |
java | apache__camel | components/camel-spring-parent/camel-spring-xml/src/test/java/org/apache/camel/spring/processor/scattergather/LowestQuoteAggregationStrategy.java | {
"start": 969,
"end": 1476
} | class ____ implements AggregationStrategy {
@Override
public Exchange aggregate(Exchange oldExchange, Exchange newExchange) {
// the first time we only have the new exchange
if (oldExchange == null) {
return newExchange;
}
if (oldExchange.getIn().getBody(int.class) < newExchange.getIn().getBody(int.class)) {
return oldExchange;
} else {
return newExchange;
}
}
}
// END SNIPPET: e1
| LowestQuoteAggregationStrategy |
java | apache__spark | sql/catalyst/src/main/java/org/apache/spark/sql/catalyst/expressions/UnsafeDataUtils.java | {
"start": 956,
"end": 1433
} | class ____ {
private UnsafeDataUtils() {
}
public static byte[] getBytes(Object baseObject, long baseOffset, int sizeInBytes) {
if (baseObject instanceof byte[] bytes
&& baseOffset == Platform.BYTE_ARRAY_OFFSET
&& (bytes.length == sizeInBytes)) {
return bytes;
}
byte[] bytes = new byte[sizeInBytes];
Platform.copyMemory(baseObject, baseOffset, bytes, Platform.BYTE_ARRAY_OFFSET,
sizeInBytes);
return bytes;
}
}
| UnsafeDataUtils |
java | google__error-prone | core/src/test/java/com/google/errorprone/bugpatterns/MultiVariableDeclarationTest.java | {
"start": 6354,
"end": 6472
} | class ____ {
int x;
int y;
}
""")
.doTest(TEXT_MATCH);
}
}
| A |
java | google__gson | gson/src/test/java/com/google/gson/functional/JsonAdapterAnnotationOnFieldsTest.java | {
"start": 6524,
"end": 6762
} | class ____ {
// overrides the JsonAdapter annotation of User with this
@JsonAdapter(UserFieldAnnotationAdapter.class)
final User user;
Computer2(User user) {
this.user = user;
}
}
private static final | Computer2 |
java | apache__camel | components/camel-huawei/camel-huaweicloud-obs/src/test/java/org/apache/camel/component/huaweicloud/obs/constants/OBSHeadersTest.java | {
"start": 971,
"end": 1483
} | class ____ {
@Test
public void testHeaders() {
assertEquals("CamelHwCloudObsBucketName", OBSHeaders.BUCKET_NAME);
assertEquals("CamelHwCloudObsObjectKey", OBSHeaders.OBJECT_KEY);
assertEquals("CamelHwCloudObsLastModified", OBSHeaders.LAST_MODIFIED);
assertEquals("CamelHwCloudObsETag", OBSHeaders.ETAG);
assertEquals("CamelHwCloudObsContentMD5", OBSHeaders.CONTENT_MD5);
assertEquals("CamelHwCloudObsObjectType", OBSHeaders.OBJECT_TYPE);
}
}
| OBSHeadersTest |
java | netty__netty | handler-proxy/src/test/java/io/netty/handler/proxy/HttpProxyServer.java | {
"start": 1714,
"end": 4056
} | class ____ extends ProxyServer {
HttpProxyServer(boolean useSsl, TestMode testMode, InetSocketAddress destination) {
super(useSsl, testMode, destination);
}
HttpProxyServer(
boolean useSsl, TestMode testMode, InetSocketAddress destination, String username, String password) {
super(useSsl, testMode, destination, username, password);
}
@Override
protected void configure(SocketChannel ch) throws Exception {
ChannelPipeline p = ch.pipeline();
switch (testMode) {
case INTERMEDIARY:
p.addLast(new HttpServerCodec());
p.addLast(new HttpObjectAggregator(1));
p.addLast(new HttpIntermediaryHandler());
break;
case TERMINAL:
p.addLast(new HttpServerCodec());
p.addLast(new HttpObjectAggregator(1));
p.addLast(new HttpTerminalHandler());
break;
case UNRESPONSIVE:
p.addLast(UnresponsiveHandler.INSTANCE);
break;
}
}
private boolean authenticate(ChannelHandlerContext ctx, FullHttpRequest req) {
assertEquals(HttpMethod.CONNECT, req.method());
if (testMode != TestMode.INTERMEDIARY) {
ctx.pipeline().addBefore(ctx.name(), "lineDecoder", new LineBasedFrameDecoder(64, false, true));
}
ctx.pipeline().remove(HttpObjectAggregator.class);
ctx.pipeline().get(HttpServerCodec.class).removeInboundHandler();
boolean authzSuccess = false;
if (username != null) {
CharSequence authz = req.headers().get(HttpHeaderNames.PROXY_AUTHORIZATION);
if (authz != null) {
String[] authzParts = authz.toString().split(" ", 2);
ByteBuf authzBuf64 = Unpooled.copiedBuffer(authzParts[1], CharsetUtil.US_ASCII);
ByteBuf authzBuf = Base64.decode(authzBuf64);
String expectedAuthz = username + ':' + password;
authzSuccess = "Basic".equals(authzParts[0]) &&
expectedAuthz.equals(authzBuf.toString(CharsetUtil.US_ASCII));
authzBuf64.release();
authzBuf.release();
}
} else {
authzSuccess = true;
}
return authzSuccess;
}
private final | HttpProxyServer |
java | spring-projects__spring-boot | documentation/spring-boot-docs/src/main/java/org/springframework/boot/docs/packaging/nativeimage/advanced/customhints/MyRuntimeHints.java | {
"start": 961,
"end": 1551
} | class ____ implements RuntimeHintsRegistrar {
@Override
public void registerHints(RuntimeHints hints, ClassLoader classLoader) {
// Register method for reflection
Method method = ReflectionUtils.findMethod(MyClass.class, "sayHello", String.class);
hints.reflection().registerMethod(method, ExecutableMode.INVOKE);
// Register resources
hints.resources().registerPattern("my-resource.txt");
// Register serialization
hints.serialization().registerType(MySerializableClass.class);
// Register proxy
hints.proxies().registerJdkProxy(MyInterface.class);
}
}
| MyRuntimeHints |
java | google__guice | core/test/com/google/inject/TypeConversionTest.java | {
"start": 9466,
"end": 10614
} | class ____ extends AbstractModule {
@Override
protected void configure() {
convertToTypes(Matchers.only(TypeLiteral.get(Date.class)), failingTypeConverter());
bindConstant().annotatedWith(NumericValue.class).to("invalid");
bind(DateHolder.class);
}
}
public void testInvalidCustomValue() throws CreationException {
Module module = new InvalidCustomValueModule();
try {
Guice.createInjector(module);
fail();
} catch (CreationException expected) {
Throwable cause = Iterables.getOnlyElement(expected.getErrorMessages()).getCause();
assertTrue(cause instanceof UnsupportedOperationException);
assertContains(
expected.getMessage(),
"Error converting 'invalid'",
"bound at TypeConversionTest$InvalidCustomValueModule.configure",
"to Date",
"using BrokenConverter which matches only(Date)",
"bound at TypeConversionTest$InvalidCustomValueModule.configure",
"Reason: UnsupportedOperationException: Cannot convert",
"at TypeConversionTest$DateHolder.date");
}
}
static | InvalidCustomValueModule |
java | quarkusio__quarkus | extensions/websockets-next/spi/src/main/java/io/quarkus/websockets/next/runtime/spi/telemetry/WebSocketMetricsInterceptorProducer.java | {
"start": 184,
"end": 649
} | interface ____ {
/**
* Creates {@link WebSocketMetricsInterceptor} for server endpoints.
*
* @return WebSocketMetricsInterceptor
*/
WebSocketMetricsInterceptor createServerMetricsInterceptor();
/**
* Creates {@link WebSocketMetricsInterceptor} for client endpoints.
*
* @return WebSocketMetricsInterceptor
*/
WebSocketMetricsInterceptor createClientMetricsInterceptor();
| WebSocketMetricsInterceptorProducer |
java | apache__camel | core/camel-core/src/test/java/org/apache/camel/processor/SplitParallelThreadPoolAbortTest.java | {
"start": 1536,
"end": 3266
} | class ____ extends ContextTestSupport {
@Test
public void testSplitParallel() throws Exception {
AtomicInteger ok = new AtomicInteger();
AtomicInteger fail = new AtomicInteger();
Runnable r = () -> {
try {
template.sendBody("direct:start", List.of(List.of("0-0", "0-1"), List.of("1-0", "1-1")));
ok.incrementAndGet();
} catch (Exception e) {
fail.incrementAndGet();
}
};
var pool = Executors.newFixedThreadPool(10);
for (int i = 0; i < 10; i++) {
pool.submit(r);
}
Awaitility.await().untilAsserted(() -> {
Assertions.assertEquals(10, fail.get(), "All should fail");
});
log.info("Errors: {}", fail.get());
log.info("OK: {}", ok.get());
}
@Override
protected RoutesBuilder createRouteBuilder() throws Exception {
return new RouteBuilder() {
@Override
public void configure() throws Exception {
final var executorService = new ThreadPoolBuilder(getContext())
.poolSize(1)
.maxPoolSize(1)
.maxQueueSize(0)
.rejectedPolicy(ThreadPoolRejectedPolicy.Abort)
.build("inner");
from("direct:start")
.split(body()).parallelProcessing()
.to("direct:inner?synchronous=true");
from("direct:inner")
.split(body()).executorService(executorService)
.log("${body}");
}
};
}
}
| SplitParallelThreadPoolAbortTest |
java | elastic__elasticsearch | x-pack/plugin/ml/src/test/java/org/elasticsearch/xpack/ml/dataframe/inference/InferenceRunnerTests.java | {
"start": 12673,
"end": 13311
} | class ____ implements ActionListener<Void> {
private final AtomicBoolean success = new AtomicBoolean(false);
private final AtomicReference<Exception> failure = new AtomicReference<>();
@Override
public void onResponse(Void t) {
success.set(true);
}
@Override
public void onFailure(Exception e) {
failure.set(e);
}
public void assertSuccess() {
assertTrue(success.get());
}
public Exception assertFailure() {
assertNotNull(failure.get());
return failure.get();
}
}
}
| TestListener |
java | quarkusio__quarkus | extensions/panache/hibernate-orm-rest-data-panache/deployment/src/test/java/io/quarkus/hibernate/orm/rest/data/panache/deployment/entity/ItemsResource.java | {
"start": 240,
"end": 310
} | interface ____ extends PanacheEntityResource<Item, Long> {
}
| ItemsResource |
java | quarkusio__quarkus | core/deployment/src/main/java/io/quarkus/deployment/DockerStatusProcessor.java | {
"start": 214,
"end": 449
} | class ____ {
@BuildStep
DockerStatusBuildItem IsDockerWorking(LaunchModeBuildItem launchMode) {
return new DockerStatusBuildItem(new IsDockerWorking(launchMode.getLaunchMode().isDevOrTest()));
}
}
| DockerStatusProcessor |
java | hibernate__hibernate-orm | hibernate-envers/src/test/java/org/hibernate/orm/test/envers/entities/manytomany/ListOwnedEntity.java | {
"start": 490,
"end": 1889
} | class ____ {
@Id
private Integer id;
@Audited
private String data;
@Audited
@ManyToMany(mappedBy = "references")
private List<ListOwningEntity> referencing;
public ListOwnedEntity() {
}
public ListOwnedEntity(Integer id, String data) {
this.id = id;
this.data = data;
}
public ListOwnedEntity(String data) {
this.data = data;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getData() {
return data;
}
public void setData(String data) {
this.data = data;
}
public List<ListOwningEntity> getReferencing() {
return referencing;
}
public void setReferencing(List<ListOwningEntity> referencing) {
this.referencing = referencing;
}
public boolean equals(Object o) {
if ( this == o ) {
return true;
}
if ( !(o instanceof ListOwnedEntity) ) {
return false;
}
ListOwnedEntity that = (ListOwnedEntity) o;
if ( data != null ? !data.equals( that.data ) : that.data != null ) {
return false;
}
if ( id != null ? !id.equals( that.id ) : that.id != null ) {
return false;
}
return true;
}
public int hashCode() {
int result;
result = (id != null ? id.hashCode() : 0);
result = 31 * result + (data != null ? data.hashCode() : 0);
return result;
}
public String toString() {
return "ListOwnedEntity(id = " + id + ", data = " + data + ")";
}
}
| ListOwnedEntity |
java | apache__kafka | trogdor/src/main/java/org/apache/kafka/trogdor/workload/TimestampRecordProcessor.java | {
"start": 1334,
"end": 1846
} | class ____ process records containing timestamps and generate a histogram based on the data. It will then be
* present in the status from the `ConsumeBenchWorker` class. This must be used with a timestamped PayloadGenerator
* implementation.
*
* Example spec:
* {
* "type": "timestamp",
* "histogramMaxMs": 10000,
* "histogramMinMs": 0,
* "histogramStepMs": 1
* }
*
* This will track total E2E latency up to 10 seconds, using 1ms resolution and a timestamp size of 8 bytes.
*/
public | will |
java | alibaba__nacos | naming/src/main/java/com/alibaba/nacos/naming/constants/Constants.java | {
"start": 831,
"end": 3674
} | class ____ {
public static final String SERVICE_METADATA = "naming_service_metadata";
public static final String INSTANCE_METADATA = "naming_instance_metadata";
public static final String NAMING_PERSISTENT_SERVICE_GROUP = "naming_persistent_service";
public static final String NAMING_PERSISTENT_SERVICE_GROUP_V2 = "naming_persistent_service_v2";
public static final String NACOS_NAMING_USE_NEW_RAFT_FIRST = "nacos.naming.use-new-raft.first";
/**
* Time interval to clear empty services, unit: millisecond. default: 60000 ms.
*/
public static final String EMPTY_SERVICE_CLEAN_INTERVAL = "nacos.naming.clean.empty-service.interval";
/**
* Expiration time of empty service, unit: millisecond. default: 60000 ms.
*/
public static final String EMPTY_SERVICE_EXPIRED_TIME = "nacos.naming.clean.empty-service.expired-time";
/**
* Time interval to clear expired metadata, unit: millisecond. default: 5000 ms.
*/
public static final String EXPIRED_METADATA_CLEAN_INTERVAL = "nacos.naming.clean.expired-metadata.interval";
/**
* Expiration time of expired metadata, unit: millisecond. default: 60000 ms.
*/
public static final String EXPIRED_METADATA_EXPIRED_TIME = "nacos.naming.clean.expired-metadata.expired-time";
/**
* default: false.
*/
public static final String DATA_WARMUP = "nacos.naming.data.warmup";
/**
* default : true.
*/
public static final String EXPIRE_INSTANCE = "nacos.naming.expireInstance";
/**
* UDP max retry times.
*/
public static final int UDP_MAX_RETRY_TIMES = 1;
/**
* The Nanoseconds for receive UDP ack time out.
*/
public static final long ACK_TIMEOUT_NANOS = TimeUnit.SECONDS.toNanos(10L);
/**
* The custom instance id key.
*/
public static final String CUSTOM_INSTANCE_ID = "customInstanceId";
/**
* The weight of instance according to instance self publish.
*/
public static final String PUBLISH_INSTANCE_WEIGHT = "publishInstanceWeight";
/**
* The weight of instance according to instance self publish.
*/
public static final double DEFAULT_INSTANCE_WEIGHT = 1.0D;
/**
* Whether enabled for instance according to instance self publish.
*/
public static final String PUBLISH_INSTANCE_ENABLE = "publishInstanceEnable";
/**
* Max value of instance weight.
*/
public static final double MAX_WEIGHT_VALUE = 10000.0D;
/**
* Min positive value of instance weight.
*/
public static final double MIN_POSITIVE_WEIGHT_VALUE = 0.01D;
/**
* Min value of instance weight.
*/
public static final double MIN_WEIGHT_VALUE = 0.00D;
}
| Constants |
java | reactor__reactor-core | reactor-core/src/main/java/reactor/core/publisher/MonoRetryWhen.java | {
"start": 1279,
"end": 1912
} | class ____<T> extends InternalMonoOperator<T, T> {
final Retry whenSourceFactory;
MonoRetryWhen(Mono<? extends T> source, Retry whenSourceFactory) {
super(Mono.fromDirect(source));
this.whenSourceFactory = Objects.requireNonNull(whenSourceFactory, "whenSourceFactory");
}
@Override
public @Nullable CoreSubscriber<? super T> subscribeOrReturn(CoreSubscriber<? super T> actual) {
FluxRetryWhen.subscribe(actual, whenSourceFactory, source);
return null;
}
@Override
public @Nullable Object scanUnsafe(Attr key) {
if (key == Attr.RUN_STYLE) return Attr.RunStyle.SYNC;
return super.scanUnsafe(key);
}
}
| MonoRetryWhen |
java | grpc__grpc-java | api/src/testFixtures/java/io/grpc/NoopMetricSink.java | {
"start": 775,
"end": 1249
} | class ____ implements MetricSink {
private int size;
@Override
public Map<String, Boolean> getEnabledMetrics() {
return Collections.emptyMap();
}
@Override
public Set<String> getOptionalLabels() {
return Collections.emptySet();
}
@Override
public synchronized int getMeasuresSize() {
return size;
}
@Override
public synchronized void updateMeasures(List<MetricInstrument> instruments) {
size = instruments.size();
}
}
| NoopMetricSink |
java | apache__logging-log4j2 | log4j-jpa/src/main/java/org/apache/logging/log4j/core/appender/db/jpa/converter/package-info.java | {
"start": 1810,
"end": 2025
} | class ____.
*/
// CHECKSTYLE:ON
@Export
@Version("2.20.1")
package org.apache.logging.log4j.core.appender.db.jpa.converter;
import org.osgi.annotation.bundle.Export;
import org.osgi.annotation.versioning.Version;
| path |
java | hibernate__hibernate-orm | hibernate-core/src/test/java/org/hibernate/orm/test/jpa/emops/MergeTest.java | {
"start": 610,
"end": 7717
} | class ____ {
@Test
public void testMergeWithIndexColumn(EntityManagerFactoryScope scope) {
scope.inEntityManager(
entityManager -> {
try {
Race race = new Race();
race.competitors.add( new Competitor( "Name" ) );
race.competitors.add( new Competitor() );
race.competitors.add( new Competitor() );
entityManager.getTransaction().begin();
entityManager.persist( race );
entityManager.flush();
entityManager.clear();
race.competitors.add( new Competitor() );
race.competitors.remove( 2 );
race.competitors.remove( 1 );
race.competitors.get( 0 ).setName( "Name2" );
race = entityManager.merge( race );
entityManager.flush();
entityManager.clear();
race = entityManager.find( Race.class, race.id );
assertEquals( 2, race.competitors.size() );
assertEquals( "Name2", race.competitors.get( 0 ).getName() );
entityManager.getTransaction().rollback();
}
catch (Exception e) {
if ( entityManager.getTransaction().isActive() ) {
entityManager.getTransaction().rollback();
}
throw e;
}
}
);
}
@Test
public void testMergeManyToMany(EntityManagerFactoryScope scope) {
scope.inEntityManager(
entityManager -> {
try {
Competition competition = new Competition();
competition.getCompetitors().add( new Competitor( "Name" ) );
competition.getCompetitors().add( new Competitor() );
competition.getCompetitors().add( new Competitor() );
entityManager.getTransaction().begin();
entityManager.persist( competition );
entityManager.flush();
entityManager.clear();
competition.getCompetitors().add( new Competitor() );
competition.getCompetitors().remove( 2 );
competition.getCompetitors().remove( 1 );
competition.getCompetitors().get( 0 ).setName( "Name2" );
competition = entityManager.merge( competition );
entityManager.flush();
entityManager.clear();
competition = entityManager.find( Competition.class, competition.getId() );
assertEquals( 2, competition.getCompetitors().size() );
// we cannot assume that the order in the list is maintained - HHH-4516
String changedCompetitorName;
if ( competition.getCompetitors().get( 0 ).getName() != null ) {
changedCompetitorName = competition.getCompetitors().get( 0 ).getName();
}
else {
changedCompetitorName = competition.getCompetitors().get( 1 ).getName();
}
assertEquals( "Name2", changedCompetitorName );
entityManager.getTransaction().rollback();
}
catch (Exception e) {
if ( entityManager.getTransaction().isActive() ) {
entityManager.getTransaction().rollback();
}
throw e;
}
}
);
}
@Test
public void testMergeManyToManyWithDeference(EntityManagerFactoryScope scope) {
scope.inEntityManager(
entityManager -> {
try {
Competition competition = new Competition();
competition.getCompetitors().add( new Competitor( "Name" ) );
competition.getCompetitors().add( new Competitor() );
competition.getCompetitors().add( new Competitor() );
entityManager.getTransaction().begin();
entityManager.persist( competition );
entityManager.flush();
entityManager.clear();
List<Competitor> newComp = new ArrayList<Competitor>();
newComp.add( competition.getCompetitors().get( 0 ) );
newComp.add( new Competitor() );
newComp.get( 0 ).setName( "Name2" );
competition.setCompetitors( newComp );
competition = entityManager.merge( competition );
entityManager.flush();
entityManager.clear();
competition = entityManager.find( Competition.class, competition.getId() );
assertEquals( 2, competition.getCompetitors().size() );
// we cannot assume that the order in the list is maintained - HHH-4516
String changedCompetitorName;
if ( competition.getCompetitors().get( 0 ).getName() != null ) {
changedCompetitorName = competition.getCompetitors().get( 0 ).getName();
}
else {
changedCompetitorName = competition.getCompetitors().get( 1 ).getName();
}
assertEquals( "Name2", changedCompetitorName );
entityManager.getTransaction().rollback();
}
catch (Exception e) {
if ( entityManager.getTransaction().isActive() ) {
entityManager.getTransaction().rollback();
}
throw e;
}
}
);
}
@Test
public void testRemoveAndMerge(EntityManagerFactoryScope scope) {
scope.inEntityManager(
entityManager -> {
try {
Race race = new Race();
entityManager.getTransaction().begin();
entityManager.persist( race );
entityManager.flush();
entityManager.clear();
race = entityManager.find( Race.class, race.id );
entityManager.remove( race );
try {
race = entityManager.merge( race );
entityManager.flush();
fail( "Should raise an IllegalArgumentException" );
}
catch (IllegalArgumentException e) {
//all good
}
catch (Exception e) {
fail( "Should raise an IllegalArgumentException" );
}
entityManager.getTransaction().rollback();
}
catch (Exception e) {
if ( entityManager.getTransaction().isActive() ) {
entityManager.getTransaction().rollback();
}
throw e;
}
}
);
}
@Test
public void testConcurrentMerge(EntityManagerFactoryScope scope) {
Race race = new Race();
scope.inTransaction(
entityManager -> {
race.name = "Derby";
entityManager.persist( race );
entityManager.flush();
}
);
race.name = "Magnicourt";
scope.inTransaction(
entityManager -> {
Race race2 = entityManager.find( Race.class, race.id );
race2.name = "Mans";
entityManager.merge( race );
entityManager.flush();
}
);
scope.inTransaction(
entityManager -> {
Race race2 = entityManager.find( Race.class, race.id );
assertEquals( "Magnicourt", race2.name, "Last commit win in merge" );
entityManager.remove( race2 );
}
);
}
@Test
public void testMergeUnidirectionalOneToMany(EntityManagerFactoryScope scope) {
scope.inEntityManager(
entityManager -> {
try {
entityManager.getTransaction().begin();
Empire roman = new Empire();
entityManager.persist( roman );
entityManager.flush();
entityManager.clear();
roman = entityManager.find( Empire.class, roman.getId() );
Colony gaule = new Colony();
roman.getColonies().add( gaule );
entityManager.merge( roman );
entityManager.flush();
entityManager.clear();
roman = entityManager.find( Empire.class, roman.getId() );
assertEquals( 1, roman.getColonies().size() );
entityManager.getTransaction().rollback();
}
catch (Exception e) {
if ( entityManager.getTransaction().isActive() ) {
entityManager.getTransaction().rollback();
}
throw e;
}
}
);
}
}
| MergeTest |
java | elastic__elasticsearch | x-pack/plugin/core/src/test/java/org/elasticsearch/xpack/core/action/AbstractTransportSetUpgradeModeActionTests.java | {
"start": 1552,
"end": 6396
} | class ____ extends ESTestCase {
/**
* Creates a TaskQueue that invokes the SimpleBatchedExecutor.
*/
public static ClusterService clusterService() {
AtomicReference<SimpleBatchedExecutor<? extends ClusterStateTaskListener, Void>> executor = new AtomicReference<>();
MasterServiceTaskQueue<ClusterStateTaskListener> taskQueue = mock();
ClusterService clusterService = mock();
doAnswer(ans -> {
executor.set(ans.getArgument(2));
return taskQueue;
}).when(clusterService).createTaskQueue(any(), any(), any());
doAnswer(ans -> {
if (executor.get() == null) {
fail("We should create the task queue before we submit tasks to it");
} else {
executor.get().executeTask(ans.getArgument(1), ClusterState.EMPTY_STATE);
executor.get().taskSucceeded(ans.getArgument(1), null);
}
return null;
}).when(taskQueue).submitTask(any(), any(), any());
return clusterService;
}
/**
* Creates a TaskQueue that calls the listener with an error.
*/
public static ClusterService clusterServiceWithError(Exception e) {
MasterServiceTaskQueue<ClusterStateTaskListener> taskQueue = mock();
ClusterService clusterService = mock();
when(clusterService.createTaskQueue(any(), any(), any())).thenReturn(taskQueue);
doAnswer(ans -> {
ClusterStateTaskListener listener = ans.getArgument(1);
listener.onFailure(e);
return null;
}).when(taskQueue).submitTask(any(), any(), any());
return clusterService;
}
/**
* TaskQueue that does nothing.
*/
public static ClusterService clusterServiceThatDoesNothing() {
ClusterService clusterService = mock();
when(clusterService.createTaskQueue(any(), any(), any())).thenReturn(mock());
return clusterService;
}
public void testIdempotent() throws Exception {
// create with update mode set to false
var action = new TestTransportSetUpgradeModeAction(clusterServiceThatDoesNothing(), false);
// flip to true but do nothing (cluster service mock won't invoke the listener)
action.runWithoutWaiting(true);
// call again
var response = action.run(true);
assertThat(response.v1(), nullValue());
assertThat(response.v2(), notNullValue());
assertThat(response.v2(), instanceOf(ElasticsearchStatusException.class));
assertThat(
response.v2().getMessage(),
is("Cannot change [upgrade_mode] for feature name [" + action.featureName() + "]. Previous request is still being processed.")
);
}
public void testUpdateDoesNotRun() throws Exception {
var shouldNotChange = new AtomicBoolean(true);
var action = new TestTransportSetUpgradeModeAction(true, l -> shouldNotChange.set(false));
var response = action.run(true);
assertThat(response.v1(), is(AcknowledgedResponse.TRUE));
assertThat(response.v2(), nullValue());
assertThat(shouldNotChange.get(), is(true));
}
public void testErrorReleasesLock() throws Exception {
var action = new TestTransportSetUpgradeModeAction(false, l -> l.onFailure(new IllegalStateException("hello there")));
action.run(true);
var response = action.run(true);
assertThat(
"Previous request should have finished processing.",
response.v2().getMessage(),
not(containsString("Previous request is still being processed"))
);
}
public void testErrorFromAction() throws Exception {
var expectedException = new IllegalStateException("hello there");
var action = new TestTransportSetUpgradeModeAction(false, l -> l.onFailure(expectedException));
var response = action.run(true);
assertThat(response.v1(), nullValue());
assertThat(response.v2(), is(expectedException));
}
public void testErrorFromTaskQueue() throws Exception {
var expectedException = new IllegalStateException("hello there");
var action = new TestTransportSetUpgradeModeAction(clusterServiceWithError(expectedException), false);
var response = action.run(true);
assertThat(response.v1(), nullValue());
assertThat(response.v2(), is(expectedException));
}
public void testSuccess() throws Exception {
var action = new TestTransportSetUpgradeModeAction(false, l -> l.onResponse(AcknowledgedResponse.TRUE));
var response = action.run(true);
assertThat(response.v1(), is(AcknowledgedResponse.TRUE));
assertThat(response.v2(), nullValue());
}
private static | AbstractTransportSetUpgradeModeActionTests |
java | elastic__elasticsearch | server/src/main/java/org/elasticsearch/index/mapper/RoutingFields.java | {
"start": 1763,
"end": 2686
} | enum ____ implements RoutingFields {
INSTANCE;
@Override
public RoutingFields addString(String fieldName, BytesRef utf8Value) {
return this;
}
@Override
public RoutingFields addString(String fieldName, String value) {
return this;
}
@Override
public RoutingFields addIp(String fieldName, InetAddress value) {
return this;
}
@Override
public RoutingFields addLong(String fieldName, long value) {
return this;
}
@Override
public RoutingFields addUnsignedLong(String fieldName, long value) {
return this;
}
@Override
public RoutingFields addBoolean(String fieldName, boolean value) {
return this;
}
@Override
public boolean isNoop() {
return true;
}
}
}
| Noop |
java | apache__hadoop | hadoop-yarn-project/hadoop-yarn/hadoop-yarn-common/src/main/java/org/apache/hadoop/yarn/nodelabels/AbstractLabel.java | {
"start": 1082,
"end": 1969
} | class ____ {
private Resource resource;
private int numActiveNMs;
private String labelName;
public AbstractLabel() {
super();
}
public AbstractLabel(String labelName) {
this(labelName, Resource.newInstance(0, 0), 0);
}
public AbstractLabel(String labelName, Resource resource, int numActiveNMs) {
super();
this.resource = resource;
this.numActiveNMs = numActiveNMs;
this.labelName = labelName;
}
public void addNode(Resource nodeRes) {
Resources.addTo(resource, nodeRes);
numActiveNMs++;
}
public void removeNode(Resource nodeRes) {
Resources.subtractFrom(resource, nodeRes);
numActiveNMs--;
}
public Resource getResource() {
return Resource.newInstance(this.resource);
}
public int getNumActiveNMs() {
return numActiveNMs;
}
public String getLabelName() {
return labelName;
}
} | AbstractLabel |
java | hibernate__hibernate-orm | hibernate-core/src/test/java/org/hibernate/orm/test/mapping/hhh14276/entity/Score.java | {
"start": 454,
"end": 1286
} | class ____ implements Serializable {
@Id
@Column(name = "game_id")
private Integer gameId;
@Id
@Column(name = "is_home")
private Boolean home;
@Basic(optional = false)
@Column(name = "roster_id")
private Integer rosterId;
@Basic
@Column(name = "final_score")
private Integer finalScore;
public Score() {
}
public Integer getGameId() {
return gameId;
}
public void setGameId(Integer gameId) {
this.gameId = gameId;
}
public Boolean getHome() {
return home;
}
public void setHome(Boolean home) {
this.home = home;
}
public Integer getRosterId() {
return rosterId;
}
public void setRosterId(Integer rosterId) {
this.rosterId = rosterId;
}
public Integer getFinalScore() {
return finalScore;
}
public void setFinalScore(Integer finalScore) {
this.finalScore = finalScore;
}
}
| Score |
java | apache__logging-log4j2 | log4j-api/src/main/java/org/apache/logging/log4j/util/internal/SerializationUtil.java | {
"start": 5996,
"end": 6372
} | class ____ name is returned.
* </p>
* @param clazz the binary name of a class.
*/
public static String stripArray(final Class<?> clazz) {
Class<?> currentClazz = clazz;
while (currentClazz.isArray()) {
currentClazz = currentClazz.getComponentType();
}
return currentClazz.getName();
}
/**
* Gets the | its |
java | apache__commons-lang | src/test/java/org/apache/commons/lang3/ArrayUtilsTest.java | {
"start": 10513,
"end": 323821
} | class ____ extends LANG1261ParentObject {
// empty.
}
final Object[] array = new LANG1261ChildObject[] { new LANG1261ChildObject() };
assertTrue(ArrayUtils.contains(array, new LANG1261ParentObject()));
}
@Test
void testContainsAnyEnum() {
assertTrue(ArrayUtils.containsAny(ElementType.values(), ElementType.ANNOTATION_TYPE));
assertFalse(ArrayUtils.containsAny(ElementType.values(), (ElementType) null));
}
@Test
void testContainsAnyInt() {
final int[] array = {0, 1, 2, 3, 0};
assertFalse(ArrayUtils.containsAny((int[]) null, 1));
assertTrue(ArrayUtils.containsAny(array, 0));
assertTrue(ArrayUtils.containsAny(array, 1));
assertTrue(ArrayUtils.containsAny(array, 2));
assertTrue(ArrayUtils.containsAny(array, 3));
}
@Test
void testContainsAnyObject() {
final Object[] array = {"0", "1", "2", "3", null, "0"};
assertFalse(ArrayUtils.containsAny(null, (Object) null));
assertFalse(ArrayUtils.containsAny(null, "1"));
assertTrue(ArrayUtils.containsAny(array, "0"));
assertTrue(ArrayUtils.containsAny(array, "1"));
assertTrue(ArrayUtils.containsAny(array, "2"));
assertTrue(ArrayUtils.containsAny(array, "3"));
assertFalse(ArrayUtils.containsAny(array, "notInArray"));
assertTrue(ArrayUtils.containsAny(array, (Object[]) new String[] { null }));
}
@Test
void testContainsBoolean() {
boolean[] array = null;
assertFalse(ArrayUtils.contains(array, true));
array = new boolean[]{true, false, true};
assertTrue(ArrayUtils.contains(array, true));
assertTrue(ArrayUtils.contains(array, false));
array = new boolean[]{true, true};
assertTrue(ArrayUtils.contains(array, true));
assertFalse(ArrayUtils.contains(array, false));
}
@Test
void testContainsByte() {
byte[] array = null;
assertFalse(ArrayUtils.contains(array, (byte) 1));
array = new byte[]{0, 1, 2, 3, 0};
assertTrue(ArrayUtils.contains(array, (byte) 0));
assertTrue(ArrayUtils.contains(array, (byte) 1));
assertTrue(ArrayUtils.contains(array, (byte) 2));
assertTrue(ArrayUtils.contains(array, (byte) 3));
assertFalse(ArrayUtils.contains(array, (byte) 99));
}
@Test
void testContainsChar() {
char[] array = null;
assertFalse(ArrayUtils.contains(array, 'b'));
array = new char[]{'a', 'b', 'c', 'd', 'a'};
assertTrue(ArrayUtils.contains(array, 'a'));
assertTrue(ArrayUtils.contains(array, 'b'));
assertTrue(ArrayUtils.contains(array, 'c'));
assertTrue(ArrayUtils.contains(array, 'd'));
assertFalse(ArrayUtils.contains(array, 'e'));
}
@Test
void testContainsDouble() {
double[] array = null;
assertFalse(ArrayUtils.contains(array, 1));
array = new double[]{0, 1, 2, 3, 0};
assertTrue(ArrayUtils.contains(array, 0));
assertTrue(ArrayUtils.contains(array, 1));
assertTrue(ArrayUtils.contains(array, 2));
assertTrue(ArrayUtils.contains(array, 3));
assertFalse(ArrayUtils.contains(array, 99));
}
@Test
void testContainsDoubleNaN() {
final double[] a = { Double.NEGATIVE_INFINITY, Double.NaN, Double.POSITIVE_INFINITY };
assertTrue(ArrayUtils.contains(a, Double.POSITIVE_INFINITY));
assertTrue(ArrayUtils.contains(a, Double.NEGATIVE_INFINITY));
assertTrue(ArrayUtils.contains(a, Double.NaN));
}
@Test
void testContainsDoubleTolerance() {
double[] array = null;
assertFalse(ArrayUtils.contains(array, 1, 0));
array = new double[]{0, 1, 2, 3, 0};
assertFalse(ArrayUtils.contains(array, 4.0, 0.33));
assertFalse(ArrayUtils.contains(array, 2.5, 0.49));
assertTrue(ArrayUtils.contains(array, 2.5, 0.50));
assertTrue(ArrayUtils.contains(array, 2.5, 0.51));
}
@Test
void testContainsFloat() {
float[] array = null;
assertFalse(ArrayUtils.contains(array, 1));
array = new float[]{0, 1, 2, 3, 0};
assertTrue(ArrayUtils.contains(array, 0));
assertTrue(ArrayUtils.contains(array, 1));
assertTrue(ArrayUtils.contains(array, 2));
assertTrue(ArrayUtils.contains(array, 3));
assertFalse(ArrayUtils.contains(array, 99));
}
@Test
void testContainsFloatNaN() {
final float[] array = { Float.NEGATIVE_INFINITY, Float.NaN, Float.POSITIVE_INFINITY };
assertTrue(ArrayUtils.contains(array, Float.POSITIVE_INFINITY));
assertTrue(ArrayUtils.contains(array, Float.NEGATIVE_INFINITY));
assertTrue(ArrayUtils.contains(array, Float.NaN));
}
@Test
void testContainsInt() {
int[] array = null;
assertFalse(ArrayUtils.contains(array, 1));
array = new int[]{0, 1, 2, 3, 0};
assertTrue(ArrayUtils.contains(array, 0));
assertTrue(ArrayUtils.contains(array, 1));
assertTrue(ArrayUtils.contains(array, 2));
assertTrue(ArrayUtils.contains(array, 3));
assertFalse(ArrayUtils.contains(array, 99));
}
@Test
void testContainsLong() {
long[] array = null;
assertFalse(ArrayUtils.contains(array, 1));
array = new long[]{0, 1, 2, 3, 0};
assertTrue(ArrayUtils.contains(array, 0));
assertTrue(ArrayUtils.contains(array, 1));
assertTrue(ArrayUtils.contains(array, 2));
assertTrue(ArrayUtils.contains(array, 3));
assertFalse(ArrayUtils.contains(array, 99));
}
@Test
void testContainsShort() {
short[] array = null;
assertFalse(ArrayUtils.contains(array, (short) 1));
array = new short[]{0, 1, 2, 3, 0};
assertTrue(ArrayUtils.contains(array, (short) 0));
assertTrue(ArrayUtils.contains(array, (short) 1));
assertTrue(ArrayUtils.contains(array, (short) 2));
assertTrue(ArrayUtils.contains(array, (short) 3));
assertFalse(ArrayUtils.contains(array, (short) 99));
}
/**
* Tests generic empty array creation with generic type.
*/
@Test
void testEmptyArrayCreation() {
final String[] array = ArrayUtils.<String>toArray();
assertEquals(0, array.length);
}
@Test
void testGet() {
assertNull(ArrayUtils.get(null, -1));
assertNull(ArrayUtils.get(null, 0));
assertNull(ArrayUtils.get(null, 1));
final String[] array0 = {};
assertNull(ArrayUtils.get(array0, -1));
assertNull(ArrayUtils.get(array0, 0));
assertNull(ArrayUtils.get(array0, 1));
final String[] array1 = { StringUtils.EMPTY };
assertNull(ArrayUtils.get(array1, -1));
assertEquals(StringUtils.EMPTY, ArrayUtils.get(array1, 0));
assertNull(ArrayUtils.get(array1, 1));
}
@Test
void testGetComponentType() {
final TestClass[] newArray = {};
// No type-cast required.
final Class<TestClass> componentType = ArrayUtils.getComponentType(newArray);
assertEquals(TestClass.class, componentType);
assertNull(ArrayUtils.getComponentType(null));
}
@Test
void testGetDefault() {
// null default
{
assertNull(ArrayUtils.get(null, -1, null));
assertNull(ArrayUtils.get(null, 0, null));
assertNull(ArrayUtils.get(null, 1, null));
final String[] array0 = {};
assertNull(ArrayUtils.get(array0, -1, null));
assertNull(ArrayUtils.get(array0, 0, null));
assertNull(ArrayUtils.get(array0, 1, null));
final String[] array1 = { StringUtils.EMPTY };
assertNull(ArrayUtils.get(array1, -1, null));
assertEquals(StringUtils.EMPTY, ArrayUtils.get(array1, 0, null));
assertNull(ArrayUtils.get(array1, 1, null));
}
// non-null default
{
final String defaultValue = "defaultValue";
final String[] array1 = { StringUtils.EMPTY };
assertEquals(defaultValue, ArrayUtils.get(array1, -1, defaultValue));
assertEquals(StringUtils.EMPTY, ArrayUtils.get(array1, 0, defaultValue));
assertEquals(defaultValue, ArrayUtils.get(array1, 1, defaultValue));
}
}
@Test
void testGetLength() {
assertEquals(0, ArrayUtils.getLength(null));
final Object[] emptyObjectArray = {};
final Object[] notEmptyObjectArray = {"aValue"};
assertEquals(0, ArrayUtils.getLength(null));
assertEquals(0, ArrayUtils.getLength(emptyObjectArray));
assertEquals(1, ArrayUtils.getLength(notEmptyObjectArray));
final int[] emptyIntArray = {};
final int[] notEmptyIntArray = {1};
assertEquals(0, ArrayUtils.getLength(null));
assertEquals(0, ArrayUtils.getLength(emptyIntArray));
assertEquals(1, ArrayUtils.getLength(notEmptyIntArray));
final short[] emptyShortArray = {};
final short[] notEmptyShortArray = {1};
assertEquals(0, ArrayUtils.getLength(null));
assertEquals(0, ArrayUtils.getLength(emptyShortArray));
assertEquals(1, ArrayUtils.getLength(notEmptyShortArray));
final char[] emptyCharArray = {};
final char[] notEmptyCharArray = {1};
assertEquals(0, ArrayUtils.getLength(null));
assertEquals(0, ArrayUtils.getLength(emptyCharArray));
assertEquals(1, ArrayUtils.getLength(notEmptyCharArray));
final byte[] emptyByteArray = {};
final byte[] notEmptyByteArray = {1};
assertEquals(0, ArrayUtils.getLength(null));
assertEquals(0, ArrayUtils.getLength(emptyByteArray));
assertEquals(1, ArrayUtils.getLength(notEmptyByteArray));
final double[] emptyDoubleArray = {};
final double[] notEmptyDoubleArray = {1.0};
assertEquals(0, ArrayUtils.getLength(null));
assertEquals(0, ArrayUtils.getLength(emptyDoubleArray));
assertEquals(1, ArrayUtils.getLength(notEmptyDoubleArray));
final float[] emptyFloatArray = {};
final float[] notEmptyFloatArray = {1.0F};
assertEquals(0, ArrayUtils.getLength(null));
assertEquals(0, ArrayUtils.getLength(emptyFloatArray));
assertEquals(1, ArrayUtils.getLength(notEmptyFloatArray));
final boolean[] emptyBooleanArray = {};
final boolean[] notEmptyBooleanArray = {true};
assertEquals(0, ArrayUtils.getLength(null));
assertEquals(0, ArrayUtils.getLength(emptyBooleanArray));
assertEquals(1, ArrayUtils.getLength(notEmptyBooleanArray));
assertIllegalArgumentException(() -> ArrayUtils.getLength("notAnArray"));
}
@Test
void testHashCode() {
final long[][] array1 = {{2, 5}, {4, 5}};
final long[][] array2 = {{2, 5}, {4, 6}};
assertEquals(ArrayUtils.hashCode(array1), ArrayUtils.hashCode(array1));
assertNotEquals(ArrayUtils.hashCode(array1), ArrayUtils.hashCode(array2));
final Object[] array3 = {new String(new char[]{'A', 'B'})};
final Object[] array4 = {"AB"};
assertEquals(ArrayUtils.hashCode(array3), ArrayUtils.hashCode(array3));
assertEquals(ArrayUtils.hashCode(array3), ArrayUtils.hashCode(array4));
final Object[] arrayA = {new boolean[]{true, false}, new int[]{6, 7}};
final Object[] arrayB = {new boolean[]{true, false}, new int[]{6, 7}};
assertEquals(ArrayUtils.hashCode(arrayB), ArrayUtils.hashCode(arrayA));
}
@Test
void testIndexesOf() {
final Object[] array = {"0", "1", "2", "3", null, "0"};
final BitSet emptySet = new BitSet();
final BitSet testSet = new BitSet();
assertEquals(emptySet, ArrayUtils.indexesOf((Object[]) null, null));
assertEquals(emptySet, ArrayUtils.indexesOf(new Object[0], "0"));
testSet.set(5);
testSet.set(0);
assertEquals(testSet, ArrayUtils.indexesOf(array, "0"));
testSet.clear();
testSet.set(2);
assertEquals(testSet, ArrayUtils.indexesOf(array, "2"));
testSet.clear();
testSet.set(3);
assertEquals(testSet, ArrayUtils.indexesOf(array, "3"));
testSet.clear();
testSet.set(4);
assertEquals(testSet, ArrayUtils.indexesOf(array, null));
assertEquals(emptySet, ArrayUtils.indexesOf(array, "notInArray"));
}
@Test
void testIndexesOfBoolean() {
boolean[] array = null;
final BitSet emptySet = new BitSet();
final BitSet testSet = new BitSet();
assertEquals(emptySet, ArrayUtils.indexesOf(array, true));
array = new boolean[0];
assertEquals(emptySet, ArrayUtils.indexesOf(array, true));
array = new boolean[]{true, false, true};
testSet.set(0);
testSet.set(2);
assertEquals(testSet, ArrayUtils.indexesOf(array, true));
testSet.clear();
testSet.set(1);
assertEquals(testSet, ArrayUtils.indexesOf(array, false));
array = new boolean[]{true, true};
assertEquals(emptySet, ArrayUtils.indexesOf(array, false));
}
@Test
void testIndexesOfBooleanWithStartIndex() {
boolean[] array = null;
final BitSet emptySet = new BitSet();
final BitSet testSet = new BitSet();
assertEquals(emptySet, ArrayUtils.indexesOf(array, true, 0));
array = new boolean[0];
assertEquals(emptySet, ArrayUtils.indexesOf(array, true, 0));
array = new boolean[]{true, false, true};
testSet.set(2);
assertEquals(testSet, ArrayUtils.indexesOf(array, true, 1));
testSet.set(0);
assertEquals(testSet, ArrayUtils.indexesOf(array, true, 0));
testSet.clear();
testSet.set(1);
assertEquals(testSet, ArrayUtils.indexesOf(array, false, 1));
array = new boolean[]{true, true};
assertEquals(emptySet, ArrayUtils.indexesOf(array, false, 0));
assertEquals(emptySet, ArrayUtils.indexesOf(array, false, -1));
}
@Test
void testIndexesOfByte() {
byte[] array = null;
final BitSet emptySet = new BitSet();
final BitSet testSet = new BitSet();
assertEquals(emptySet, ArrayUtils.indexesOf(array, (byte) 0));
array = new byte[]{0, 1, 2, 3, 0};
testSet.set(0);
testSet.set(4);
assertEquals(testSet, ArrayUtils.indexesOf(array, (byte) 0));
testSet.clear();
testSet.set(1);
assertEquals(testSet, ArrayUtils.indexesOf(array, (byte) 1));
testSet.clear();
testSet.set(2);
assertEquals(testSet, ArrayUtils.indexesOf(array, (byte) 2));
testSet.clear();
testSet.set(3);
assertEquals(testSet, ArrayUtils.indexesOf(array, (byte) 3));
assertEquals(emptySet, ArrayUtils.indexesOf(array, (byte) 99));
}
@Test
void testIndexesOfByteWithStartIndex() {
byte[] array = null;
final BitSet emptySet = new BitSet();
final BitSet testSet = new BitSet();
assertEquals(emptySet, ArrayUtils.indexesOf(array, (byte) 0, 2));
array = new byte[]{0, 1, 2, 3, 0};
testSet.set(4);
assertEquals(testSet, ArrayUtils.indexesOf(array, (byte) 0, 2));
testSet.set(0);
assertEquals(testSet, ArrayUtils.indexesOf(array, (byte) 0, 0));
testSet.clear();
testSet.set(1);
assertEquals(testSet, ArrayUtils.indexesOf(array, (byte) 1, 1));
testSet.clear();
testSet.set(2);
assertEquals(testSet, ArrayUtils.indexesOf(array, (byte) 2, 0));
testSet.clear();
testSet.set(3);
assertEquals(testSet, ArrayUtils.indexesOf(array, (byte) 3, 0));
assertEquals(testSet, ArrayUtils.indexesOf(array, (byte) 3, -1));
assertEquals(emptySet, ArrayUtils.indexesOf(array, (byte) 99, 0));
}
@Test
void testIndexesOfChar() {
char[] array = null;
final BitSet emptySet = new BitSet();
final BitSet testSet = new BitSet();
assertEquals(emptySet, ArrayUtils.indexesOf(array, 'a'));
array = new char[]{'a', 'b', 'c', 'd', 'a'};
testSet.set(0);
testSet.set(4);
assertEquals(testSet, ArrayUtils.indexesOf(array, 'a'));
testSet.clear();
testSet.set(1);
assertEquals(testSet, ArrayUtils.indexesOf(array, 'b'));
testSet.clear();
testSet.set(2);
assertEquals(testSet, ArrayUtils.indexesOf(array, 'c'));
testSet.clear();
testSet.set(3);
assertEquals(testSet, ArrayUtils.indexesOf(array, 'd'));
assertEquals(emptySet, ArrayUtils.indexesOf(array, 'e'));
}
@Test
void testIndexesOfCharWithStartIndex() {
char[] array = null;
final BitSet emptySet = new BitSet();
final BitSet testSet = new BitSet();
assertEquals(emptySet, ArrayUtils.indexesOf(array, 'a', 0));
array = new char[]{'a', 'b', 'c', 'd', 'a'};
testSet.set(4);
assertEquals(testSet, ArrayUtils.indexesOf(array, 'a', 2));
testSet.set(0);
assertEquals(testSet, ArrayUtils.indexesOf(array, 'a', 0));
assertEquals(testSet, ArrayUtils.indexesOf(array, 'a', -1));
testSet.clear();
testSet.set(1);
assertEquals(testSet, ArrayUtils.indexesOf(array, 'b', 1));
testSet.clear();
testSet.set(2);
assertEquals(testSet, ArrayUtils.indexesOf(array, 'c', 0));
testSet.clear();
testSet.set(3);
assertEquals(testSet, ArrayUtils.indexesOf(array, 'd', 0));
assertEquals(emptySet, ArrayUtils.indexesOf(array, 'd', 5));
assertEquals(emptySet, ArrayUtils.indexesOf(array, 'e', 0));
}
@Test
void testIndexesOfDouble() {
double[] array = null;
final BitSet emptySet = new BitSet();
final BitSet testSet = new BitSet();
assertEquals(emptySet, ArrayUtils.indexesOf(array, 0));
array = new double[]{0, 1, 2, 3, 0};
testSet.set(0);
testSet.set(4);
assertEquals(testSet, ArrayUtils.indexesOf(array, 0));
testSet.clear();
testSet.set(1);
assertEquals(testSet, ArrayUtils.indexesOf(array, 1));
testSet.clear();
testSet.set(2);
assertEquals(testSet, ArrayUtils.indexesOf(array, 2));
testSet.clear();
testSet.set(3);
assertEquals(testSet, ArrayUtils.indexesOf(array, 3));
assertEquals(emptySet, ArrayUtils.indexesOf(array, 99));
}
@Test
void testIndexesOfDoubleTolerance() {
double[] array = null;
final BitSet emptySet = new BitSet();
final BitSet testSet = new BitSet();
assertEquals(emptySet, ArrayUtils.indexesOf(array, (double) 0, (double) 0));
array = new double[0];
assertEquals(emptySet, ArrayUtils.indexesOf(array, (double) 0, (double) 0));
array = new double[]{0, 1, 2, 3, 0};
testSet.set(0);
testSet.set(4);
assertEquals(testSet, ArrayUtils.indexesOf(array, 0, 0.3));
testSet.clear();
testSet.set(3);
assertEquals(testSet, ArrayUtils.indexesOf(array, 4.15, 2.0));
testSet.clear();
testSet.set(1);
assertEquals(testSet, ArrayUtils.indexesOf(array, 1.00001324, 0.0001));
}
@Test
void testIndexesOfDoubleWithStartIndex() {
double[] array = null;
final BitSet emptySet = new BitSet();
final BitSet testSet = new BitSet();
assertEquals(emptySet, ArrayUtils.indexesOf(array, 0, 2));
array = new double[]{0, 1, 2, 3, 0};
testSet.set(4);
assertEquals(testSet, ArrayUtils.indexesOf(array, 0, 2));
testSet.set(0);
assertEquals(testSet, ArrayUtils.indexesOf(array, 0, 0));
testSet.clear();
testSet.set(1);
assertEquals(testSet, ArrayUtils.indexesOf(array, 1, 1));
testSet.clear();
testSet.set(2);
assertEquals(testSet, ArrayUtils.indexesOf(array, 2, 0));
testSet.clear();
testSet.set(3);
assertEquals(testSet, ArrayUtils.indexesOf(array, 3, 0));
assertEquals(testSet, ArrayUtils.indexesOf(array, 3, -1));
assertEquals(emptySet, ArrayUtils.indexesOf(array, 99, 0));
}
@Test
void testIndexesOfDoubleWithStartIndexTolerance() {
double[] array = null;
final BitSet emptySet = new BitSet();
final BitSet testSet = new BitSet();
assertEquals(emptySet, ArrayUtils.indexesOf(array, 0, 0, 0));
array = new double[0];
assertEquals(emptySet, ArrayUtils.indexesOf(array, 0, 0, 0));
array = new double[]{0, 1, 2, 3, 0};
testSet.set(4);
assertEquals(testSet, ArrayUtils.indexesOf(array, 0, 1, 0.3));
testSet.set(0);
assertEquals(testSet, ArrayUtils.indexesOf(array, 0, 0, 0.3));
testSet.clear();
testSet.set(2);
assertEquals(testSet, ArrayUtils.indexesOf(array, 2, 0, 0.35));
assertEquals(testSet, ArrayUtils.indexesOf(array, 2, 2, 0.35));
assertEquals(testSet, ArrayUtils.indexesOf(array, 2, -1, 0.35));
assertEquals(emptySet, ArrayUtils.indexesOf(array, 2, 3, 0.35));
testSet.clear();
testSet.set(3);
assertEquals(testSet, ArrayUtils.indexesOf(array, 4.15, 0, 2.0));
testSet.clear();
testSet.set(1);
assertEquals(testSet, ArrayUtils.indexesOf(array, 1.00001324, 0, 0.0001));
}
@Test
void testIndexesOfFloat() {
float[] array = null;
final BitSet emptySet = new BitSet();
final BitSet testSet = new BitSet();
assertEquals(emptySet, ArrayUtils.indexesOf(array, 0));
array = new float[]{0, 1, 2, 3, 0};
testSet.set(0);
testSet.set(4);
assertEquals(testSet, ArrayUtils.indexesOf(array, 0));
testSet.clear();
testSet.set(1);
assertEquals(testSet, ArrayUtils.indexesOf(array, 1));
testSet.clear();
testSet.set(2);
assertEquals(testSet, ArrayUtils.indexesOf(array, 2));
testSet.clear();
testSet.set(3);
assertEquals(testSet, ArrayUtils.indexesOf(array, 3));
assertEquals(emptySet, ArrayUtils.indexesOf(array, 99));
}
@Test
void testIndexesOfFloatWithStartIndex() {
float[] array = null;
final BitSet emptySet = new BitSet();
final BitSet testSet = new BitSet();
assertEquals(emptySet, ArrayUtils.indexesOf(array, 0, 2));
array = new float[]{0, 1, 2, 3, 0};
testSet.set(4);
assertEquals(testSet, ArrayUtils.indexesOf(array, 0, 2));
testSet.set(0);
assertEquals(testSet, ArrayUtils.indexesOf(array, 0, 0));
testSet.clear();
testSet.set(1);
assertEquals(testSet, ArrayUtils.indexesOf(array, 1, 1));
testSet.clear();
testSet.set(2);
assertEquals(testSet, ArrayUtils.indexesOf(array, 2, 0));
testSet.clear();
testSet.set(3);
assertEquals(testSet, ArrayUtils.indexesOf(array, 3, 0));
assertEquals(testSet, ArrayUtils.indexesOf(array, 3, -1));
assertEquals(emptySet, ArrayUtils.indexesOf(array, 99, 0));
}
@Test
void testIndexesOfIntWithStartIndex() {
int[] array = null;
final BitSet emptySet = new BitSet();
final BitSet testSet = new BitSet();
assertEquals(emptySet, ArrayUtils.indexesOf(array, 0, 2));
array = new int[]{0, 1, 2, 3, 0};
testSet.set(4);
assertEquals(testSet, ArrayUtils.indexesOf(array, 0, 2));
testSet.set(0);
assertEquals(testSet, ArrayUtils.indexesOf(array, 0, 0));
testSet.clear();
testSet.set(1);
assertEquals(testSet, ArrayUtils.indexesOf(array, 1, 1));
testSet.clear();
testSet.set(2);
assertEquals(testSet, ArrayUtils.indexesOf(array, 2, 0));
testSet.clear();
testSet.set(3);
assertEquals(testSet, ArrayUtils.indexesOf(array, 3, 0));
assertEquals(testSet, ArrayUtils.indexesOf(array, 3, -1));
assertEquals(emptySet, ArrayUtils.indexesOf(array, 99, 0));
}
@Test
void testIndexesOfLong() {
final long[] array = {0, 1, 2, 3};
final BitSet emptySet = new BitSet();
final BitSet testSet = new BitSet();
assertEquals(emptySet, ArrayUtils.indexesOf((long[]) null, 0));
assertEquals(emptySet, ArrayUtils.indexesOf(array, 4));
testSet.set(0);
assertEquals(testSet, ArrayUtils.indexesOf(array, 0));
testSet.clear();
testSet.set(1);
assertEquals(testSet, ArrayUtils.indexesOf(array, 1));
testSet.clear();
testSet.set(2);
assertEquals(testSet, ArrayUtils.indexesOf(array, 2));
testSet.clear();
testSet.set(3);
assertEquals(testSet, ArrayUtils.indexesOf(array, 3));
}
@Test
void testIndexesOfLongWithStartIndex() {
final long[] array = {0, 1, 2, 3, 2, 1, 0, 1};
final BitSet emptySet = new BitSet();
final BitSet testSet = new BitSet();
assertEquals(emptySet, ArrayUtils.indexesOf((long[]) null, 0, 0));
assertEquals(emptySet, ArrayUtils.indexesOf(array, 4, 0));
testSet.set(6);
assertEquals(testSet, ArrayUtils.indexesOf(array, 0, 1));
testSet.set(0);
assertEquals(testSet, ArrayUtils.indexesOf(array, 0, 0));
testSet.clear();
testSet.set(1);
testSet.set(5);
testSet.set(7);
assertEquals(testSet, ArrayUtils.indexesOf(array, 1, 0));
testSet.clear();
testSet.set(2);
testSet.set(4);
assertEquals(testSet, ArrayUtils.indexesOf(array, 2, 0));
testSet.clear();
testSet.set(3);
assertEquals(testSet, ArrayUtils.indexesOf(array, 3, 0));
assertEquals(emptySet, ArrayUtils.indexesOf(array, 3, 8));
}
@Test
void testIndexesOfShort() {
short[] array = null;
final BitSet emptySet = new BitSet();
final BitSet testSet = new BitSet();
assertEquals(emptySet, ArrayUtils.indexesOf(array, (short) 0));
array = new short[]{0, 1, 2, 3, 0};
testSet.set(0);
testSet.set(4);
assertEquals(testSet, ArrayUtils.indexesOf(array, (short) 0));
testSet.clear();
testSet.set(1);
assertEquals(testSet, ArrayUtils.indexesOf(array, (short) 1));
testSet.clear();
testSet.set(2);
assertEquals(testSet, ArrayUtils.indexesOf(array, (short) 2));
testSet.clear();
testSet.set(3);
assertEquals(testSet, ArrayUtils.indexesOf(array, (short) 3));
assertEquals(emptySet, ArrayUtils.indexesOf(array, (short) 99));
}
@Test
void testIndexesOfShortWithStartIndex() {
short[] array = null;
final BitSet emptySet = new BitSet();
final BitSet testSet = new BitSet();
assertEquals(emptySet, ArrayUtils.indexesOf(array, (short) 0, 2));
array = new short[]{0, 1, 2, 3, 0};
testSet.set(4);
assertEquals(testSet, ArrayUtils.indexesOf(array, (short) 0, 2));
testSet.set(0);
assertEquals(testSet, ArrayUtils.indexesOf(array, (short) 0, 0));
testSet.clear();
testSet.set(1);
assertEquals(testSet, ArrayUtils.indexesOf(array, (short) 1, 1));
testSet.clear();
testSet.set(2);
assertEquals(testSet, ArrayUtils.indexesOf(array, (short) 2, 0));
testSet.clear();
testSet.set(3);
assertEquals(testSet, ArrayUtils.indexesOf(array, (short) 3, 0));
assertEquals(testSet, ArrayUtils.indexesOf(array, (short) 3, -1));
assertEquals(emptySet, ArrayUtils.indexesOf(array, (short) 99, 0));
}
@Test
void testIndexesOfWithStartIndex() {
final Object[] array = {"0", "1", "2", "3", "2", "3", "1", null, "0"};
final BitSet emptySet = new BitSet();
final BitSet testSet = new BitSet();
assertEquals(emptySet, ArrayUtils.indexesOf(null, null, 2));
assertEquals(emptySet, ArrayUtils.indexesOf(new Object[0], "0", 0));
assertEquals(emptySet, ArrayUtils.indexesOf(null, "0", 2));
testSet.set(8);
assertEquals(testSet, ArrayUtils.indexesOf(array, "0", 8));
testSet.set(0);
assertEquals(testSet, ArrayUtils.indexesOf(array, "0", 0));
testSet.clear();
testSet.set(6);
testSet.set(1);
assertEquals(testSet, ArrayUtils.indexesOf(array, "1", 0));
assertEquals(emptySet, ArrayUtils.indexesOf(array, "1", 9));
testSet.clear();
testSet.set(4);
assertEquals(testSet, ArrayUtils.indexesOf(array, "2", 3));
testSet.set(2);
assertEquals(testSet, ArrayUtils.indexesOf(array, "2", 0));
testSet.clear();
testSet.set(3);
testSet.set(5);
assertEquals(testSet, ArrayUtils.indexesOf(array, "3", 0));
testSet.clear();
testSet.set(7);
assertEquals(testSet, ArrayUtils.indexesOf(array, null, 0));
}
@Test
void testIndexOf() {
final Object[] array = {"0", "1", "2", "3", null, "0"};
assertEquals(-1, ArrayUtils.indexOf(null, null));
assertEquals(-1, ArrayUtils.indexOf(null, "0"));
assertEquals(-1, ArrayUtils.indexOf(new Object[0], "0"));
assertEquals(0, ArrayUtils.indexOf(array, "0"));
assertEquals(1, ArrayUtils.indexOf(array, "1"));
assertEquals(2, ArrayUtils.indexOf(array, "2"));
assertEquals(3, ArrayUtils.indexOf(array, "3"));
assertEquals(4, ArrayUtils.indexOf(array, null));
assertEquals(-1, ArrayUtils.indexOf(array, "notInArray"));
}
@Test
void testIndexOfBoolean() {
boolean[] array = null;
assertEquals(-1, ArrayUtils.indexOf(array, true));
array = new boolean[0];
assertEquals(-1, ArrayUtils.indexOf(array, true));
array = new boolean[]{true, false, true};
assertEquals(0, ArrayUtils.indexOf(array, true));
assertEquals(1, ArrayUtils.indexOf(array, false));
array = new boolean[]{true, true};
assertEquals(-1, ArrayUtils.indexOf(array, false));
}
@Test
void testIndexOfBooleanWithStartIndex() {
boolean[] array = null;
assertEquals(-1, ArrayUtils.indexOf(array, true, 2));
array = new boolean[0];
assertEquals(-1, ArrayUtils.indexOf(array, true, 2));
array = new boolean[]{true, false, true};
assertEquals(2, ArrayUtils.indexOf(array, true, 1));
assertEquals(-1, ArrayUtils.indexOf(array, false, 2));
assertEquals(1, ArrayUtils.indexOf(array, false, 0));
assertEquals(1, ArrayUtils.indexOf(array, false, -1));
array = new boolean[]{true, true};
assertEquals(-1, ArrayUtils.indexOf(array, false, 0));
assertEquals(-1, ArrayUtils.indexOf(array, false, -1));
}
@Test
void testIndexOfByte() {
byte[] array = null;
assertEquals(-1, ArrayUtils.indexOf(array, (byte) 0));
array = new byte[]{0, 1, 2, 3, 0};
assertEquals(0, ArrayUtils.indexOf(array, (byte) 0));
assertEquals(1, ArrayUtils.indexOf(array, (byte) 1));
assertEquals(2, ArrayUtils.indexOf(array, (byte) 2));
assertEquals(3, ArrayUtils.indexOf(array, (byte) 3));
assertEquals(-1, ArrayUtils.indexOf(array, (byte) 99));
}
@Test
void testIndexOfByteWithStartIndex() {
byte[] array = null;
assertEquals(-1, ArrayUtils.indexOf(array, (byte) 0, 2));
array = new byte[]{0, 1, 2, 3, 0};
assertEquals(4, ArrayUtils.indexOf(array, (byte) 0, 2));
assertEquals(-1, ArrayUtils.indexOf(array, (byte) 1, 2));
assertEquals(2, ArrayUtils.indexOf(array, (byte) 2, 2));
assertEquals(3, ArrayUtils.indexOf(array, (byte) 3, 2));
assertEquals(3, ArrayUtils.indexOf(array, (byte) 3, -1));
assertEquals(-1, ArrayUtils.indexOf(array, (byte) 99, 0));
assertEquals(-1, ArrayUtils.indexOf(array, (byte) 0, 6));
}
@Test
void testIndexOfChar() {
char[] array = null;
assertEquals(-1, ArrayUtils.indexOf(array, 'a'));
array = new char[]{'a', 'b', 'c', 'd', 'a'};
assertEquals(0, ArrayUtils.indexOf(array, 'a'));
assertEquals(1, ArrayUtils.indexOf(array, 'b'));
assertEquals(2, ArrayUtils.indexOf(array, 'c'));
assertEquals(3, ArrayUtils.indexOf(array, 'd'));
assertEquals(-1, ArrayUtils.indexOf(array, 'e'));
}
@Test
void testIndexOfCharWithStartIndex() {
char[] array = null;
assertEquals(-1, ArrayUtils.indexOf(array, 'a', 2));
array = new char[]{'a', 'b', 'c', 'd', 'a'};
assertEquals(4, ArrayUtils.indexOf(array, 'a', 2));
assertEquals(-1, ArrayUtils.indexOf(array, 'b', 2));
assertEquals(2, ArrayUtils.indexOf(array, 'c', 2));
assertEquals(3, ArrayUtils.indexOf(array, 'd', 2));
assertEquals(3, ArrayUtils.indexOf(array, 'd', -1));
assertEquals(-1, ArrayUtils.indexOf(array, 'e', 0));
assertEquals(-1, ArrayUtils.indexOf(array, 'a', 6));
}
@Test
void testIndexOfDouble() {
double[] array = null;
assertEquals(-1, ArrayUtils.indexOf(array, 0));
array = new double[0];
assertEquals(-1, ArrayUtils.indexOf(array, 0));
array = new double[]{0, 1, 2, 3, 0};
assertEquals(0, ArrayUtils.indexOf(array, 0));
assertEquals(1, ArrayUtils.indexOf(array, 1));
assertEquals(2, ArrayUtils.indexOf(array, 2));
assertEquals(3, ArrayUtils.indexOf(array, 3));
assertEquals(3, ArrayUtils.indexOf(array, 3, -1));
assertEquals(-1, ArrayUtils.indexOf(array, 99));
}
@Test
void testIndexOfDoubleNaN() {
final double[] array = { Double.NEGATIVE_INFINITY, Double.NaN, Double.POSITIVE_INFINITY, Double.NaN };
assertEquals(0, ArrayUtils.indexOf(array, Double.NEGATIVE_INFINITY));
assertEquals(1, ArrayUtils.indexOf(array, Double.NaN));
assertEquals(2, ArrayUtils.indexOf(array, Double.POSITIVE_INFINITY));
}
@Test
void testIndexOfDoubleTolerance() {
double[] array = null;
assertEquals(-1, ArrayUtils.indexOf(array, (double) 0, (double) 0));
array = new double[0];
assertEquals(-1, ArrayUtils.indexOf(array, (double) 0, (double) 0));
array = new double[]{0, 1, 2, 3, 0};
assertEquals(0, ArrayUtils.indexOf(array, 0, 0.3));
assertEquals(2, ArrayUtils.indexOf(array, 2.2, 0.35));
assertEquals(3, ArrayUtils.indexOf(array, 4.15, 2.0));
assertEquals(1, ArrayUtils.indexOf(array, 1.00001324, 0.0001));
}
@Test
void testIndexOfDoubleWithStartIndex() {
double[] array = null;
assertEquals(-1, ArrayUtils.indexOf(array, 0, 2));
array = new double[0];
assertEquals(-1, ArrayUtils.indexOf(array, 0, 2));
array = new double[]{0, 1, 2, 3, 0};
assertEquals(4, ArrayUtils.indexOf(array, 0, 2));
assertEquals(-1, ArrayUtils.indexOf(array, 1, 2));
assertEquals(2, ArrayUtils.indexOf(array, 2, 2));
assertEquals(3, ArrayUtils.indexOf(array, 3, 2));
assertEquals(-1, ArrayUtils.indexOf(array, 99, 0));
assertEquals(-1, ArrayUtils.indexOf(array, 0, 6));
}
@Test
void testIndexOfDoubleWithStartIndexTolerance() {
double[] array = null;
assertEquals(-1, ArrayUtils.indexOf(array, 0, 2, 0));
array = new double[0];
assertEquals(-1, ArrayUtils.indexOf(array, 0, 2, 0));
array = new double[]{0, 1, 2, 3, 0};
assertEquals(-1, ArrayUtils.indexOf(array, 0, 99, 0.3));
assertEquals(0, ArrayUtils.indexOf(array, 0, 0, 0.3));
assertEquals(4, ArrayUtils.indexOf(array, 0, 3, 0.3));
assertEquals(2, ArrayUtils.indexOf(array, 2.2, 0, 0.35));
assertEquals(3, ArrayUtils.indexOf(array, 4.15, 0, 2.0));
assertEquals(1, ArrayUtils.indexOf(array, 1.00001324, 0, 0.0001));
assertEquals(3, ArrayUtils.indexOf(array, 4.15, -1, 2.0));
assertEquals(1, ArrayUtils.indexOf(array, 1.00001324, -300, 0.0001));
}
@Test
void testIndexOfFloat() {
float[] array = null;
assertEquals(-1, ArrayUtils.indexOf(array, 0));
array = new float[0];
assertEquals(-1, ArrayUtils.indexOf(array, 0));
array = new float[]{0, 1, 2, 3, 0};
assertEquals(0, ArrayUtils.indexOf(array, 0));
assertEquals(1, ArrayUtils.indexOf(array, 1));
assertEquals(2, ArrayUtils.indexOf(array, 2));
assertEquals(3, ArrayUtils.indexOf(array, 3));
assertEquals(-1, ArrayUtils.indexOf(array, 99));
}
@Test
void testIndexOfFloatNaN() {
final float[] array = { Float.NEGATIVE_INFINITY, Float.NaN, Float.POSITIVE_INFINITY, Float.NaN };
assertEquals(0, ArrayUtils.indexOf(array, Float.NEGATIVE_INFINITY));
assertEquals(1, ArrayUtils.indexOf(array, Float.NaN));
assertEquals(2, ArrayUtils.indexOf(array, Float.POSITIVE_INFINITY));
}
@Test
void testIndexOfFloatWithStartIndex() {
float[] array = null;
assertEquals(-1, ArrayUtils.indexOf(array, 0, 2));
array = new float[0];
assertEquals(-1, ArrayUtils.indexOf(array, 0, 2));
array = new float[]{0, 1, 2, 3, 0};
assertEquals(4, ArrayUtils.indexOf(array, 0, 2));
assertEquals(-1, ArrayUtils.indexOf(array, 1, 2));
assertEquals(2, ArrayUtils.indexOf(array, 2, 2));
assertEquals(3, ArrayUtils.indexOf(array, 3, 2));
assertEquals(3, ArrayUtils.indexOf(array, 3, -1));
assertEquals(-1, ArrayUtils.indexOf(array, 99, 0));
assertEquals(-1, ArrayUtils.indexOf(array, 0, 6));
}
@Test
void testIndexOfInt() {
int[] array = null;
assertEquals(-1, ArrayUtils.indexOf(array, 0));
array = new int[]{0, 1, 2, 3, 0};
assertEquals(0, ArrayUtils.indexOf(array, 0));
assertEquals(1, ArrayUtils.indexOf(array, 1));
assertEquals(2, ArrayUtils.indexOf(array, 2));
assertEquals(3, ArrayUtils.indexOf(array, 3));
assertEquals(-1, ArrayUtils.indexOf(array, 99));
}
@Test
void testIndexOfIntWithStartIndex() {
int[] array = null;
assertEquals(-1, ArrayUtils.indexOf(array, 0, 2));
array = new int[]{0, 1, 2, 3, 0};
assertEquals(4, ArrayUtils.indexOf(array, 0, 2));
assertEquals(-1, ArrayUtils.indexOf(array, 1, 2));
assertEquals(2, ArrayUtils.indexOf(array, 2, 2));
assertEquals(3, ArrayUtils.indexOf(array, 3, 2));
assertEquals(3, ArrayUtils.indexOf(array, 3, -1));
assertEquals(-1, ArrayUtils.indexOf(array, 99, 0));
assertEquals(-1, ArrayUtils.indexOf(array, 0, 6));
}
@Test
void testIndexOfLong() {
long[] array = null;
assertEquals(-1, ArrayUtils.indexOf(array, 0));
array = new long[]{0, 1, 2, 3, 0};
assertEquals(0, ArrayUtils.indexOf(array, 0));
assertEquals(1, ArrayUtils.indexOf(array, 1));
assertEquals(2, ArrayUtils.indexOf(array, 2));
assertEquals(3, ArrayUtils.indexOf(array, 3));
assertEquals(-1, ArrayUtils.indexOf(array, 99));
}
@Test
void testIndexOfLongWithStartIndex() {
long[] array = null;
assertEquals(-1, ArrayUtils.indexOf(array, 0, 2));
array = new long[]{0, 1, 2, 3, 0};
assertEquals(4, ArrayUtils.indexOf(array, 0, 2));
assertEquals(-1, ArrayUtils.indexOf(array, 1, 2));
assertEquals(2, ArrayUtils.indexOf(array, 2, 2));
assertEquals(3, ArrayUtils.indexOf(array, 3, 2));
assertEquals(3, ArrayUtils.indexOf(array, 3, -1));
assertEquals(-1, ArrayUtils.indexOf(array, 99, 0));
assertEquals(-1, ArrayUtils.indexOf(array, 0, 6));
}
@Test
void testIndexOfShort() {
short[] array = null;
assertEquals(-1, ArrayUtils.indexOf(array, (short) 0));
array = new short[]{0, 1, 2, 3, 0};
assertEquals(0, ArrayUtils.indexOf(array, (short) 0));
assertEquals(1, ArrayUtils.indexOf(array, (short) 1));
assertEquals(2, ArrayUtils.indexOf(array, (short) 2));
assertEquals(3, ArrayUtils.indexOf(array, (short) 3));
assertEquals(-1, ArrayUtils.indexOf(array, (short) 99));
}
@Test
void testIndexOfShortWithStartIndex() {
short[] array = null;
assertEquals(-1, ArrayUtils.indexOf(array, (short) 0, 2));
array = new short[]{0, 1, 2, 3, 0};
assertEquals(4, ArrayUtils.indexOf(array, (short) 0, 2));
assertEquals(-1, ArrayUtils.indexOf(array, (short) 1, 2));
assertEquals(2, ArrayUtils.indexOf(array, (short) 2, 2));
assertEquals(3, ArrayUtils.indexOf(array, (short) 3, 2));
assertEquals(3, ArrayUtils.indexOf(array, (short) 3, -1));
assertEquals(-1, ArrayUtils.indexOf(array, (short) 99, 0));
assertEquals(-1, ArrayUtils.indexOf(array, (short) 0, 6));
}
@Test
void testIndexOfWithStartIndex() {
final Object[] array = {"0", "1", "2", "3", null, "0"};
assertEquals(-1, ArrayUtils.indexOf(null, null, 2));
assertEquals(-1, ArrayUtils.indexOf(new Object[0], "0", 0));
assertEquals(-1, ArrayUtils.indexOf(null, "0", 2));
assertEquals(5, ArrayUtils.indexOf(array, "0", 2));
assertEquals(-1, ArrayUtils.indexOf(array, "1", 2));
assertEquals(2, ArrayUtils.indexOf(array, "2", 2));
assertEquals(3, ArrayUtils.indexOf(array, "3", 2));
assertEquals(4, ArrayUtils.indexOf(array, null, 2));
assertEquals(-1, ArrayUtils.indexOf(array, "notInArray", 2));
assertEquals(4, ArrayUtils.indexOf(array, null, -1));
assertEquals(-1, ArrayUtils.indexOf(array, null, 8));
assertEquals(-1, ArrayUtils.indexOf(array, "0", 8));
}
/**
* Tests generic array creation with generic type.
*/
@Test
void testIndirectArrayCreation() {
final String[] array = toArrayPropagatingType("foo", "bar");
assertEquals(2, array.length);
assertEquals("foo", array[0]);
assertEquals("bar", array[1]);
}
/**
* Tests indirect generic empty array creation with generic type.
*/
@Test
void testIndirectEmptyArrayCreation() {
final String[] array = ArrayUtilsTest.<String>toArrayPropagatingType();
assertEquals(0, array.length);
}
@Test
void testIsArrayIndexValid() {
assertFalse(ArrayUtils.isArrayIndexValid(null, 0));
final String[] array = new String[1];
//too big
assertFalse(ArrayUtils.isArrayIndexValid(array, 1));
//negative index
assertFalse(ArrayUtils.isArrayIndexValid(array, -1));
//good to go
assertTrue(ArrayUtils.isArrayIndexValid(array, 0));
}
/**
* Test for {@link ArrayUtils#isEmpty(java.lang.Object[])}.
*/
@Test
void testIsEmptyObject() {
final Object[] emptyArray = {};
final Object[] notEmptyArray = {"Value"};
assertTrue(ArrayUtils.isEmpty((Object[]) null));
assertTrue(ArrayUtils.isEmpty(emptyArray));
assertFalse(ArrayUtils.isEmpty(notEmptyArray));
}
/**
* Tests for {@link ArrayUtils#isEmpty(long[])},
* {@link ArrayUtils#isEmpty(int[])},
* {@link ArrayUtils#isEmpty(short[])},
* {@link ArrayUtils#isEmpty(char[])},
* {@link ArrayUtils#isEmpty(byte[])},
* {@link ArrayUtils#isEmpty(double[])},
* {@link ArrayUtils#isEmpty(float[])} and
* {@link ArrayUtils#isEmpty(boolean[])}.
*/
@Test
void testIsEmptyPrimitives() {
final long[] emptyLongArray = {};
final long[] notEmptyLongArray = {1L};
assertTrue(ArrayUtils.isEmpty((long[]) null));
assertTrue(ArrayUtils.isEmpty(emptyLongArray));
assertFalse(ArrayUtils.isEmpty(notEmptyLongArray));
final int[] emptyIntArray = {};
final int[] notEmptyIntArray = {1};
assertTrue(ArrayUtils.isEmpty((int[]) null));
assertTrue(ArrayUtils.isEmpty(emptyIntArray));
assertFalse(ArrayUtils.isEmpty(notEmptyIntArray));
final short[] emptyShortArray = {};
final short[] notEmptyShortArray = {1};
assertTrue(ArrayUtils.isEmpty((short[]) null));
assertTrue(ArrayUtils.isEmpty(emptyShortArray));
assertFalse(ArrayUtils.isEmpty(notEmptyShortArray));
final char[] emptyCharArray = {};
final char[] notEmptyCharArray = {1};
assertTrue(ArrayUtils.isEmpty((char[]) null));
assertTrue(ArrayUtils.isEmpty(emptyCharArray));
assertFalse(ArrayUtils.isEmpty(notEmptyCharArray));
final byte[] emptyByteArray = {};
final byte[] notEmptyByteArray = {1};
assertTrue(ArrayUtils.isEmpty((byte[]) null));
assertTrue(ArrayUtils.isEmpty(emptyByteArray));
assertFalse(ArrayUtils.isEmpty(notEmptyByteArray));
final double[] emptyDoubleArray = {};
final double[] notEmptyDoubleArray = {1.0};
assertTrue(ArrayUtils.isEmpty((double[]) null));
assertTrue(ArrayUtils.isEmpty(emptyDoubleArray));
assertFalse(ArrayUtils.isEmpty(notEmptyDoubleArray));
final float[] emptyFloatArray = {};
final float[] notEmptyFloatArray = {1.0F};
assertTrue(ArrayUtils.isEmpty((float[]) null));
assertTrue(ArrayUtils.isEmpty(emptyFloatArray));
assertFalse(ArrayUtils.isEmpty(notEmptyFloatArray));
final boolean[] emptyBooleanArray = {};
final boolean[] notEmptyBooleanArray = {true};
assertTrue(ArrayUtils.isEmpty((boolean[]) null));
assertTrue(ArrayUtils.isEmpty(emptyBooleanArray));
assertFalse(ArrayUtils.isEmpty(notEmptyBooleanArray));
}
@Test
void testIsEquals() {
final long[][] larray1 = {{2, 5}, {4, 5}};
final long[][] larray2 = {{2, 5}, {4, 6}};
final long[] larray3 = {2, 5};
assertIsEquals(larray1, larray2, larray3);
final int[][] iarray1 = {{2, 5}, {4, 5}};
final int[][] iarray2 = {{2, 5}, {4, 6}};
final int[] iarray3 = {2, 5};
assertIsEquals(iarray1, iarray2, iarray3);
final short[][] sarray1 = {{2, 5}, {4, 5}};
final short[][] sarray2 = {{2, 5}, {4, 6}};
final short[] sarray3 = {2, 5};
assertIsEquals(sarray1, sarray2, sarray3);
final float[][] farray1 = {{2, 5}, {4, 5}};
final float[][] farray2 = {{2, 5}, {4, 6}};
final float[] farray3 = {2, 5};
assertIsEquals(farray1, farray2, farray3);
final double[][] darray1 = {{2, 5}, {4, 5}};
final double[][] darray2 = {{2, 5}, {4, 6}};
final double[] darray3 = {2, 5};
assertIsEquals(darray1, darray2, darray3);
final byte[][] byteArray1 = {{2, 5}, {4, 5}};
final byte[][] byteArray2 = {{2, 5}, {4, 6}};
final byte[] byteArray3 = {2, 5};
assertIsEquals(byteArray1, byteArray2, byteArray3);
final char[][] charArray1 = {{2, 5}, {4, 5}};
final char[][] charArray2 = {{2, 5}, {4, 6}};
final char[] charArray3 = {2, 5};
assertIsEquals(charArray1, charArray2, charArray3);
final boolean[][] barray1 = {{true, false}, {true, true}};
final boolean[][] barray2 = {{true, false}, {true, false}};
final boolean[] barray3 = {false, true};
assertIsEquals(barray1, barray2, barray3);
final Object[] array3 = {new String(new char[]{'A', 'B'})};
final Object[] array4 = {"AB"};
assertTrue(ArrayUtils.isEquals(array3, array3));
assertTrue(ArrayUtils.isEquals(array3, array4));
assertTrue(ArrayUtils.isEquals(null, null));
assertFalse(ArrayUtils.isEquals(null, array4));
}
/**
* Test for {@link ArrayUtils#isNotEmpty(java.lang.Object[])}.
*/
@Test
void testIsNotEmptyObject() {
final Object[] emptyArray = {};
final Object[] notEmptyArray = {"Value"};
assertFalse(ArrayUtils.isNotEmpty((Object[]) null));
assertFalse(ArrayUtils.isNotEmpty(emptyArray));
assertTrue(ArrayUtils.isNotEmpty(notEmptyArray));
}
/**
* Tests for {@link ArrayUtils#isNotEmpty(long[])},
* {@link ArrayUtils#isNotEmpty(int[])},
* {@link ArrayUtils#isNotEmpty(short[])},
* {@link ArrayUtils#isNotEmpty(char[])},
* {@link ArrayUtils#isNotEmpty(byte[])},
* {@link ArrayUtils#isNotEmpty(double[])},
* {@link ArrayUtils#isNotEmpty(float[])} and
* {@link ArrayUtils#isNotEmpty(boolean[])}.
*/
@Test
void testIsNotEmptyPrimitives() {
final long[] emptyLongArray = {};
final long[] notEmptyLongArray = {1L};
assertFalse(ArrayUtils.isNotEmpty((long[]) null));
assertFalse(ArrayUtils.isNotEmpty(emptyLongArray));
assertTrue(ArrayUtils.isNotEmpty(notEmptyLongArray));
final int[] emptyIntArray = {};
final int[] notEmptyIntArray = {1};
assertFalse(ArrayUtils.isNotEmpty((int[]) null));
assertFalse(ArrayUtils.isNotEmpty(emptyIntArray));
assertTrue(ArrayUtils.isNotEmpty(notEmptyIntArray));
final short[] emptyShortArray = {};
final short[] notEmptyShortArray = {1};
assertFalse(ArrayUtils.isNotEmpty((short[]) null));
assertFalse(ArrayUtils.isNotEmpty(emptyShortArray));
assertTrue(ArrayUtils.isNotEmpty(notEmptyShortArray));
final char[] emptyCharArray = {};
final char[] notEmptyCharArray = {1};
assertFalse(ArrayUtils.isNotEmpty((char[]) null));
assertFalse(ArrayUtils.isNotEmpty(emptyCharArray));
assertTrue(ArrayUtils.isNotEmpty(notEmptyCharArray));
final byte[] emptyByteArray = {};
final byte[] notEmptyByteArray = {1};
assertFalse(ArrayUtils.isNotEmpty((byte[]) null));
assertFalse(ArrayUtils.isNotEmpty(emptyByteArray));
assertTrue(ArrayUtils.isNotEmpty(notEmptyByteArray));
final double[] emptyDoubleArray = {};
final double[] notEmptyDoubleArray = {1.0};
assertFalse(ArrayUtils.isNotEmpty((double[]) null));
assertFalse(ArrayUtils.isNotEmpty(emptyDoubleArray));
assertTrue(ArrayUtils.isNotEmpty(notEmptyDoubleArray));
final float[] emptyFloatArray = {};
final float[] notEmptyFloatArray = {1.0F};
assertFalse(ArrayUtils.isNotEmpty((float[]) null));
assertFalse(ArrayUtils.isNotEmpty(emptyFloatArray));
assertTrue(ArrayUtils.isNotEmpty(notEmptyFloatArray));
final boolean[] emptyBooleanArray = {};
final boolean[] notEmptyBooleanArray = {true};
assertFalse(ArrayUtils.isNotEmpty((boolean[]) null));
assertFalse(ArrayUtils.isNotEmpty(emptyBooleanArray));
assertTrue(ArrayUtils.isNotEmpty(notEmptyBooleanArray));
}
@Test
void testIsSorted() {
Integer[] array = null;
assertTrue(ArrayUtils.isSorted(array));
array = new Integer[]{1};
assertTrue(ArrayUtils.isSorted(array));
array = new Integer[]{1, 2, 3};
assertTrue(ArrayUtils.isSorted(array));
array = new Integer[]{1, 3, 2};
assertFalse(ArrayUtils.isSorted(array));
}
@Test
void testIsSortedBool() {
boolean[] array = null;
assertTrue(ArrayUtils.isSorted(array));
array = new boolean[]{true};
assertTrue(ArrayUtils.isSorted(array));
array = new boolean[]{false, true};
assertTrue(ArrayUtils.isSorted(array));
array = new boolean[]{true, false};
assertFalse(ArrayUtils.isSorted(array));
}
@Test
void testIsSortedByte() {
byte[] array = null;
assertTrue(ArrayUtils.isSorted(array));
array = new byte[]{0x10};
assertTrue(ArrayUtils.isSorted(array));
array = new byte[]{0x10, 0x20, 0x30};
assertTrue(ArrayUtils.isSorted(array));
array = new byte[]{0x10, 0x30, 0x20};
assertFalse(ArrayUtils.isSorted(array));
}
@Test
void testIsSortedChar() {
char[] array = null;
assertTrue(ArrayUtils.isSorted(array));
array = new char[]{'a'};
assertTrue(ArrayUtils.isSorted(array));
array = new char[]{'a', 'b', 'c'};
assertTrue(ArrayUtils.isSorted(array));
array = new char[]{'a', 'c', 'b'};
assertFalse(ArrayUtils.isSorted(array));
}
@Test
void testIsSortedComparator() {
final Comparator<Integer> c = Comparator.reverseOrder();
Integer[] array = null;
assertTrue(ArrayUtils.isSorted(array, c));
array = new Integer[]{1};
assertTrue(ArrayUtils.isSorted(array, c));
array = new Integer[]{3, 2, 1};
assertTrue(ArrayUtils.isSorted(array, c));
array = new Integer[]{1, 3, 2};
assertFalse(ArrayUtils.isSorted(array, c));
}
@Test
void testIsSortedDouble() {
double[] array = null;
assertTrue(ArrayUtils.isSorted(array));
array = new double[]{0.0};
assertTrue(ArrayUtils.isSorted(array));
array = new double[]{-1.0, 0.0, 0.1, 0.2};
assertTrue(ArrayUtils.isSorted(array));
array = new double[]{-1.0, 0.2, 0.1, 0.0};
assertFalse(ArrayUtils.isSorted(array));
}
@Test
void testIsSortedFloat() {
float[] array = null;
assertTrue(ArrayUtils.isSorted(array));
array = new float[]{0f};
assertTrue(ArrayUtils.isSorted(array));
array = new float[]{-1f, 0f, 0.1f, 0.2f};
assertTrue(ArrayUtils.isSorted(array));
array = new float[]{-1f, 0.2f, 0.1f, 0f};
assertFalse(ArrayUtils.isSorted(array));
}
@Test
void testIsSortedInt() {
int[] array = null;
assertTrue(ArrayUtils.isSorted(array));
array = new int[]{1};
assertTrue(ArrayUtils.isSorted(array));
array = new int[]{1, 2, 3};
assertTrue(ArrayUtils.isSorted(array));
array = new int[]{1, 3, 2};
assertFalse(ArrayUtils.isSorted(array));
}
@Test
void testIsSortedLong() {
long[] array = null;
assertTrue(ArrayUtils.isSorted(array));
array = new long[]{0L};
assertTrue(ArrayUtils.isSorted(array));
array = new long[]{-1L, 0L, 1L};
assertTrue(ArrayUtils.isSorted(array));
array = new long[]{-1L, 1L, 0L};
assertFalse(ArrayUtils.isSorted(array));
}
@Test
void testIsSortedNullComparator() {
assertNullPointerException(() -> ArrayUtils.isSorted(null, null));
}
@Test
void testIsSortedShort() {
short[] array = null;
assertTrue(ArrayUtils.isSorted(array));
array = new short[]{0};
assertTrue(ArrayUtils.isSorted(array));
array = new short[]{-1, 0, 1};
assertTrue(ArrayUtils.isSorted(array));
array = new short[]{-1, 1, 0};
assertFalse(ArrayUtils.isSorted(array));
}
@Test
void testLastIndexOf() {
final Object[] array = {"0", "1", "2", "3", null, "0"};
assertEquals(-1, ArrayUtils.lastIndexOf(null, null));
assertEquals(-1, ArrayUtils.lastIndexOf(null, "0"));
assertEquals(5, ArrayUtils.lastIndexOf(array, "0"));
assertEquals(1, ArrayUtils.lastIndexOf(array, "1"));
assertEquals(2, ArrayUtils.lastIndexOf(array, "2"));
assertEquals(3, ArrayUtils.lastIndexOf(array, "3"));
assertEquals(4, ArrayUtils.lastIndexOf(array, null));
assertEquals(-1, ArrayUtils.lastIndexOf(array, "notInArray"));
}
@Test
void testLastIndexOfBoolean() {
boolean[] array = null;
assertEquals(-1, ArrayUtils.lastIndexOf(array, true));
array = new boolean[0];
assertEquals(-1, ArrayUtils.lastIndexOf(array, true));
array = new boolean[]{true, false, true};
assertEquals(2, ArrayUtils.lastIndexOf(array, true));
assertEquals(1, ArrayUtils.lastIndexOf(array, false));
array = new boolean[]{true, true};
assertEquals(-1, ArrayUtils.lastIndexOf(array, false));
}
@Test
void testLastIndexOfBooleanWithStartIndex() {
boolean[] array = null;
assertEquals(-1, ArrayUtils.lastIndexOf(array, true, 2));
array = new boolean[0];
assertEquals(-1, ArrayUtils.lastIndexOf(array, true, 2));
array = new boolean[]{true, false, true};
assertEquals(2, ArrayUtils.lastIndexOf(array, true, 2));
assertEquals(0, ArrayUtils.lastIndexOf(array, true, 1));
assertEquals(1, ArrayUtils.lastIndexOf(array, false, 2));
assertEquals(-1, ArrayUtils.lastIndexOf(array, true, -1));
array = new boolean[]{true, true};
assertEquals(-1, ArrayUtils.lastIndexOf(array, false, 2));
assertEquals(-1, ArrayUtils.lastIndexOf(array, true, -1));
}
@Test
void testLastIndexOfByte() {
byte[] array = null;
assertEquals(-1, ArrayUtils.lastIndexOf(array, (byte) 0));
array = new byte[]{0, 1, 2, 3, 0};
assertEquals(4, ArrayUtils.lastIndexOf(array, (byte) 0));
assertEquals(1, ArrayUtils.lastIndexOf(array, (byte) 1));
assertEquals(2, ArrayUtils.lastIndexOf(array, (byte) 2));
assertEquals(3, ArrayUtils.lastIndexOf(array, (byte) 3));
assertEquals(-1, ArrayUtils.lastIndexOf(array, (byte) 99));
}
@Test
void testLastIndexOfByteWithStartIndex() {
byte[] array = null;
assertEquals(-1, ArrayUtils.lastIndexOf(array, (byte) 0, 2));
array = new byte[]{0, 1, 2, 3, 0};
assertEquals(0, ArrayUtils.lastIndexOf(array, (byte) 0, 2));
assertEquals(1, ArrayUtils.lastIndexOf(array, (byte) 1, 2));
assertEquals(2, ArrayUtils.lastIndexOf(array, (byte) 2, 2));
assertEquals(-1, ArrayUtils.lastIndexOf(array, (byte) 3, 2));
assertEquals(-1, ArrayUtils.lastIndexOf(array, (byte) 3, -1));
assertEquals(-1, ArrayUtils.lastIndexOf(array, (byte) 99));
assertEquals(4, ArrayUtils.lastIndexOf(array, (byte) 0, 88));
}
@Test
void testLastIndexOfChar() {
char[] array = null;
assertEquals(-1, ArrayUtils.lastIndexOf(array, 'a'));
array = new char[]{'a', 'b', 'c', 'd', 'a'};
assertEquals(4, ArrayUtils.lastIndexOf(array, 'a'));
assertEquals(1, ArrayUtils.lastIndexOf(array, 'b'));
assertEquals(2, ArrayUtils.lastIndexOf(array, 'c'));
assertEquals(3, ArrayUtils.lastIndexOf(array, 'd'));
assertEquals(-1, ArrayUtils.lastIndexOf(array, 'e'));
}
@Test
void testLastIndexOfCharWithStartIndex() {
char[] array = null;
assertEquals(-1, ArrayUtils.lastIndexOf(array, 'a', 2));
array = new char[]{'a', 'b', 'c', 'd', 'a'};
assertEquals(0, ArrayUtils.lastIndexOf(array, 'a', 2));
assertEquals(1, ArrayUtils.lastIndexOf(array, 'b', 2));
assertEquals(2, ArrayUtils.lastIndexOf(array, 'c', 2));
assertEquals(-1, ArrayUtils.lastIndexOf(array, 'd', 2));
assertEquals(-1, ArrayUtils.lastIndexOf(array, 'd', -1));
assertEquals(-1, ArrayUtils.lastIndexOf(array, 'e'));
assertEquals(4, ArrayUtils.lastIndexOf(array, 'a', 88));
}
@Test
void testLastIndexOfDouble() {
double[] array = null;
assertEquals(-1, ArrayUtils.lastIndexOf(array, 0));
array = new double[0];
assertEquals(-1, ArrayUtils.lastIndexOf(array, 0));
array = new double[]{0, 1, 2, 3, 0};
assertEquals(4, ArrayUtils.lastIndexOf(array, 0));
assertEquals(1, ArrayUtils.lastIndexOf(array, 1));
assertEquals(2, ArrayUtils.lastIndexOf(array, 2));
assertEquals(3, ArrayUtils.lastIndexOf(array, 3));
assertEquals(-1, ArrayUtils.lastIndexOf(array, 99));
}
@Test
void testLastIndexOfDoubleTolerance() {
double[] array = null;
assertEquals(-1, ArrayUtils.lastIndexOf(array, (double) 0, (double) 0));
array = new double[0];
assertEquals(-1, ArrayUtils.lastIndexOf(array, (double) 0, (double) 0));
array = new double[]{0, 1, 2, 3, 0};
assertEquals(4, ArrayUtils.lastIndexOf(array, 0, 0.3));
assertEquals(2, ArrayUtils.lastIndexOf(array, 2.2, 0.35));
assertEquals(3, ArrayUtils.lastIndexOf(array, 4.15, 2.0));
assertEquals(1, ArrayUtils.lastIndexOf(array, 1.00001324, 0.0001));
}
@Test
void testLastIndexOfDoubleWithStartIndex() {
double[] array = null;
assertEquals(-1, ArrayUtils.lastIndexOf(array, 0, 2));
array = new double[0];
assertEquals(-1, ArrayUtils.lastIndexOf(array, 0, 2));
array = new double[]{0, 1, 2, 3, 0};
assertEquals(0, ArrayUtils.lastIndexOf(array, 0, 2));
assertEquals(1, ArrayUtils.lastIndexOf(array, 1, 2));
assertEquals(2, ArrayUtils.lastIndexOf(array, 2, 2));
assertEquals(-1, ArrayUtils.lastIndexOf(array, 3, 2));
assertEquals(-1, ArrayUtils.lastIndexOf(array, 3, -1));
assertEquals(-1, ArrayUtils.lastIndexOf(array, 99));
assertEquals(4, ArrayUtils.lastIndexOf(array, 0, 88));
}
@Test
void testLastIndexOfDoubleWithStartIndexTolerance() {
double[] array = null;
assertEquals(-1, ArrayUtils.lastIndexOf(array, 0, 2, 0));
array = new double[0];
assertEquals(-1, ArrayUtils.lastIndexOf(array, 0, 2, 0));
array = new double[]{3};
assertEquals(-1, ArrayUtils.lastIndexOf(array, 1, 0, 0));
array = new double[]{0, 1, 2, 3, 0};
assertEquals(4, ArrayUtils.lastIndexOf(array, 0, 99, 0.3));
assertEquals(0, ArrayUtils.lastIndexOf(array, 0, 3, 0.3));
assertEquals(2, ArrayUtils.lastIndexOf(array, 2.2, 3, 0.35));
assertEquals(3, ArrayUtils.lastIndexOf(array, 4.15, array.length, 2.0));
assertEquals(1, ArrayUtils.lastIndexOf(array, 1.00001324, array.length, 0.0001));
assertEquals(-1, ArrayUtils.lastIndexOf(array, 4.15, -200, 2.0));
}
@Test
void testLastIndexOfFloat() {
float[] array = null;
assertEquals(-1, ArrayUtils.lastIndexOf(array, 0));
array = new float[0];
assertEquals(-1, ArrayUtils.lastIndexOf(array, 0));
array = new float[]{0, 1, 2, 3, 0};
assertEquals(4, ArrayUtils.lastIndexOf(array, 0));
assertEquals(1, ArrayUtils.lastIndexOf(array, 1));
assertEquals(2, ArrayUtils.lastIndexOf(array, 2));
assertEquals(3, ArrayUtils.lastIndexOf(array, 3));
assertEquals(-1, ArrayUtils.lastIndexOf(array, 99));
}
@Test
void testLastIndexOfFloatWithStartIndex() {
float[] array = null;
assertEquals(-1, ArrayUtils.lastIndexOf(array, 0, 2));
array = new float[0];
assertEquals(-1, ArrayUtils.lastIndexOf(array, 0, 2));
array = new float[]{0, 1, 2, 3, 0};
assertEquals(0, ArrayUtils.lastIndexOf(array, 0, 2));
assertEquals(1, ArrayUtils.lastIndexOf(array, 1, 2));
assertEquals(2, ArrayUtils.lastIndexOf(array, 2, 2));
assertEquals(-1, ArrayUtils.lastIndexOf(array, 3, 2));
assertEquals(-1, ArrayUtils.lastIndexOf(array, 3, -1));
assertEquals(-1, ArrayUtils.lastIndexOf(array, 99));
assertEquals(4, ArrayUtils.lastIndexOf(array, 0, 88));
}
@Test
void testLastIndexOfInt() {
int[] array = null;
assertEquals(-1, ArrayUtils.lastIndexOf(array, 0));
array = new int[]{0, 1, 2, 3, 0};
assertEquals(4, ArrayUtils.lastIndexOf(array, 0));
assertEquals(1, ArrayUtils.lastIndexOf(array, 1));
assertEquals(2, ArrayUtils.lastIndexOf(array, 2));
assertEquals(3, ArrayUtils.lastIndexOf(array, 3));
assertEquals(-1, ArrayUtils.lastIndexOf(array, 99));
}
@Test
void testLastIndexOfIntWithStartIndex() {
int[] array = null;
assertEquals(-1, ArrayUtils.lastIndexOf(array, 0, 2));
array = new int[]{0, 1, 2, 3, 0};
assertEquals(0, ArrayUtils.lastIndexOf(array, 0, 2));
assertEquals(1, ArrayUtils.lastIndexOf(array, 1, 2));
assertEquals(2, ArrayUtils.lastIndexOf(array, 2, 2));
assertEquals(-1, ArrayUtils.lastIndexOf(array, 3, 2));
assertEquals(-1, ArrayUtils.lastIndexOf(array, 3, -1));
assertEquals(-1, ArrayUtils.lastIndexOf(array, 99));
assertEquals(4, ArrayUtils.lastIndexOf(array, 0, 88));
}
@Test
void testLastIndexOfLong() {
long[] array = null;
assertEquals(-1, ArrayUtils.lastIndexOf(array, 0));
array = new long[]{0, 1, 2, 3, 0};
assertEquals(4, ArrayUtils.lastIndexOf(array, 0));
assertEquals(1, ArrayUtils.lastIndexOf(array, 1));
assertEquals(2, ArrayUtils.lastIndexOf(array, 2));
assertEquals(3, ArrayUtils.lastIndexOf(array, 3));
assertEquals(-1, ArrayUtils.lastIndexOf(array, 99));
}
@Test
void testLastIndexOfLongWithStartIndex() {
long[] array = null;
assertEquals(-1, ArrayUtils.lastIndexOf(array, 0, 2));
array = new long[]{0, 1, 2, 3, 0};
assertEquals(0, ArrayUtils.lastIndexOf(array, 0, 2));
assertEquals(1, ArrayUtils.lastIndexOf(array, 1, 2));
assertEquals(2, ArrayUtils.lastIndexOf(array, 2, 2));
assertEquals(-1, ArrayUtils.lastIndexOf(array, 3, 2));
assertEquals(-1, ArrayUtils.lastIndexOf(array, 3, -1));
assertEquals(-1, ArrayUtils.lastIndexOf(array, 99, 4));
assertEquals(4, ArrayUtils.lastIndexOf(array, 0, 88));
}
@Test
void testLastIndexOfShort() {
short[] array = null;
assertEquals(-1, ArrayUtils.lastIndexOf(array, (short) 0));
array = new short[]{0, 1, 2, 3, 0};
assertEquals(4, ArrayUtils.lastIndexOf(array, (short) 0));
assertEquals(1, ArrayUtils.lastIndexOf(array, (short) 1));
assertEquals(2, ArrayUtils.lastIndexOf(array, (short) 2));
assertEquals(3, ArrayUtils.lastIndexOf(array, (short) 3));
assertEquals(-1, ArrayUtils.lastIndexOf(array, (short) 99));
}
@Test
void testLastIndexOfShortWithStartIndex() {
short[] array = null;
assertEquals(-1, ArrayUtils.lastIndexOf(array, (short) 0, 2));
array = new short[]{0, 1, 2, 3, 0};
assertEquals(0, ArrayUtils.lastIndexOf(array, (short) 0, 2));
assertEquals(1, ArrayUtils.lastIndexOf(array, (short) 1, 2));
assertEquals(2, ArrayUtils.lastIndexOf(array, (short) 2, 2));
assertEquals(-1, ArrayUtils.lastIndexOf(array, (short) 3, 2));
assertEquals(-1, ArrayUtils.lastIndexOf(array, (short) 3, -1));
assertEquals(-1, ArrayUtils.lastIndexOf(array, (short) 99));
assertEquals(4, ArrayUtils.lastIndexOf(array, (short) 0, 88));
}
@Test
void testLastIndexOfWithStartIndex() {
final Object[] array = {"0", "1", "2", "3", null, "0"};
assertEquals(-1, ArrayUtils.lastIndexOf(null, null, 2));
assertEquals(-1, ArrayUtils.lastIndexOf(null, "0", 2));
assertEquals(0, ArrayUtils.lastIndexOf(array, "0", 2));
assertEquals(1, ArrayUtils.lastIndexOf(array, "1", 2));
assertEquals(2, ArrayUtils.lastIndexOf(array, "2", 2));
assertEquals(-1, ArrayUtils.lastIndexOf(array, "3", 2));
assertEquals(-1, ArrayUtils.lastIndexOf(array, "3", -1));
assertEquals(4, ArrayUtils.lastIndexOf(array, null, 5));
assertEquals(-1, ArrayUtils.lastIndexOf(array, null, 2));
assertEquals(-1, ArrayUtils.lastIndexOf(array, "notInArray", 5));
assertEquals(-1, ArrayUtils.lastIndexOf(array, null, -1));
assertEquals(5, ArrayUtils.lastIndexOf(array, "0", 88));
}
@Test
void testNullToEmptyBoolean() {
final boolean[] original = {true, false};
assertEquals(original, ArrayUtils.nullToEmpty(original));
}
@Test
void testNullToEmptyBooleanEmptyArray() {
final boolean[] empty = {};
final boolean[] result = ArrayUtils.nullToEmpty(empty);
assertEquals(ArrayUtils.EMPTY_BOOLEAN_ARRAY, result);
assertNotSame(empty, result);
}
@Test
void testNullToEmptyBooleanNull() {
assertEquals(ArrayUtils.EMPTY_BOOLEAN_ARRAY, ArrayUtils.nullToEmpty((boolean[]) null));
}
@Test
void testNullToEmptyBooleanObject() {
final Boolean[] original = {Boolean.TRUE, Boolean.FALSE};
assertArrayEquals(original, ArrayUtils.nullToEmpty(original));
}
@Test
void testNullToEmptyBooleanObjectEmptyArray() {
final Boolean[] empty = {};
final Boolean[] result = ArrayUtils.nullToEmpty(empty);
assertArrayEquals(ArrayUtils.EMPTY_BOOLEAN_OBJECT_ARRAY, result);
assertNotSame(empty, result);
}
@Test
void testNullToEmptyBooleanObjectNull() {
assertArrayEquals(ArrayUtils.EMPTY_BOOLEAN_OBJECT_ARRAY, ArrayUtils.nullToEmpty((Boolean[]) null));
}
@Test
void testNullToEmptyByte() {
final byte[] original = {0x0F, 0x0E};
assertEquals(original, ArrayUtils.nullToEmpty(original));
}
@Test
void testNullToEmptyByteEmptyArray() {
final byte[] empty = {};
final byte[] result = ArrayUtils.nullToEmpty(empty);
assertEquals(ArrayUtils.EMPTY_BYTE_ARRAY, result);
assertNotSame(empty, result);
}
@Test
void testNullToEmptyByteNull() {
assertEquals(ArrayUtils.EMPTY_BYTE_ARRAY, ArrayUtils.nullToEmpty((byte[]) null));
}
@Test
void testNullToEmptyByteObject() {
final Byte[] original = {0x0F, 0x0E};
assertArrayEquals(original, ArrayUtils.nullToEmpty(original));
}
@Test
void testNullToEmptyByteObjectEmptyArray() {
final Byte[] empty = {};
final Byte[] result = ArrayUtils.nullToEmpty(empty);
assertArrayEquals(ArrayUtils.EMPTY_BYTE_OBJECT_ARRAY, result);
assertNotSame(empty, result);
}
@Test
void testNullToEmptyByteObjectNull() {
assertArrayEquals(ArrayUtils.EMPTY_BYTE_OBJECT_ARRAY, ArrayUtils.nullToEmpty((Byte[]) null));
}
@Test
void testNullToEmptyChar() {
final char[] original = {'a', 'b'};
assertEquals(original, ArrayUtils.nullToEmpty(original));
}
@Test
void testNullToEmptyCharEmptyArray() {
final char[] empty = {};
final char[] result = ArrayUtils.nullToEmpty(empty);
assertEquals(ArrayUtils.EMPTY_CHAR_ARRAY, result);
assertNotSame(empty, result);
}
@Test
void testNullToEmptyCharNull() {
assertEquals(ArrayUtils.EMPTY_CHAR_ARRAY, ArrayUtils.nullToEmpty((char[]) null));
}
@Test
void testNullToEmptyCharObject() {
final Character[] original = {'a', 'b'};
assertArrayEquals(original, ArrayUtils.nullToEmpty(original));
}
@Test
void testNullToEmptyCharObjectEmptyArray() {
final Character[] empty = {};
final Character[] result = ArrayUtils.nullToEmpty(empty);
assertArrayEquals(ArrayUtils.EMPTY_CHARACTER_OBJECT_ARRAY, result);
assertNotSame(empty, result);
}
@Test
void testNUllToEmptyCharObjectNull() {
assertArrayEquals(ArrayUtils.EMPTY_CHARACTER_OBJECT_ARRAY, ArrayUtils.nullToEmpty((Character[]) null));
}
@Test
void testNullToEmptyClass() {
final Class<?>[] original = {Object.class, String.class};
assertArrayEquals(original, ArrayUtils.nullToEmpty(original));
}
@Test
void testNullToEmptyClassEmptyArray() {
final Class<?>[] empty = {};
final Class<?>[] result = ArrayUtils.nullToEmpty(empty);
assertArrayEquals(ArrayUtils.EMPTY_CLASS_ARRAY, result);
assertNotSame(empty, result);
}
@Test
void testNullToEmptyClassNull() {
assertArrayEquals(ArrayUtils.EMPTY_CLASS_ARRAY, ArrayUtils.nullToEmpty((Class<?>[]) null));
}
@Test
void testNullToEmptyDouble() {
final double[] original = {1L, 2L};
assertEquals(original, ArrayUtils.nullToEmpty(original));
}
@Test
void testNullToEmptyDoubleEmptyArray() {
final double[] empty = {};
final double[] result = ArrayUtils.nullToEmpty(empty);
assertEquals(ArrayUtils.EMPTY_DOUBLE_ARRAY, result);
assertNotSame(empty, result);
}
@Test
void testNullToEmptyDoubleNull() {
assertEquals(ArrayUtils.EMPTY_DOUBLE_ARRAY, ArrayUtils.nullToEmpty((double[]) null));
}
@Test
void testNullToEmptyDoubleObject() {
final Double[] original = {1D, 2D};
assertArrayEquals(original, ArrayUtils.nullToEmpty(original));
}
@Test
void testNullToEmptyDoubleObjectEmptyArray() {
final Double[] empty = {};
final Double[] result = ArrayUtils.nullToEmpty(empty);
assertArrayEquals(ArrayUtils.EMPTY_DOUBLE_OBJECT_ARRAY, result);
assertNotSame(empty, result);
}
@Test
void testNullToEmptyDoubleObjectNull() {
assertArrayEquals(ArrayUtils.EMPTY_DOUBLE_OBJECT_ARRAY, ArrayUtils.nullToEmpty((Double[]) null));
}
@Test
void testNullToEmptyFloat() {
final float[] original = {2.6f, 3.8f};
assertEquals(original, ArrayUtils.nullToEmpty(original));
}
@Test
void testNullToEmptyFloatEmptyArray() {
final float[] empty = {};
final float[] result = ArrayUtils.nullToEmpty(empty);
assertEquals(ArrayUtils.EMPTY_FLOAT_ARRAY, result);
assertNotSame(empty, result);
}
@Test
void testNullToEmptyFloatNull() {
assertEquals(ArrayUtils.EMPTY_FLOAT_ARRAY, ArrayUtils.nullToEmpty((float[]) null));
}
@Test
void testNullToEmptyFloatObject() {
final Float[] original = {2.6f, 3.8f};
assertArrayEquals(original, ArrayUtils.nullToEmpty(original));
}
@Test
void testNullToEmptyFloatObjectEmptyArray() {
final Float[] empty = {};
final Float[] result = ArrayUtils.nullToEmpty(empty);
assertArrayEquals(ArrayUtils.EMPTY_FLOAT_OBJECT_ARRAY, result);
assertNotSame(empty, result);
}
@Test
void testNullToEmptyFloatObjectNull() {
assertArrayEquals(ArrayUtils.EMPTY_FLOAT_OBJECT_ARRAY, ArrayUtils.nullToEmpty((Float[]) null));
}
@Test
void testNullToEmptyGeneric() {
final TestClass[] input = {new TestClass(), new TestClass()};
final TestClass[] output = ArrayUtils.nullToEmpty(input, TestClass[].class);
assertSame(input, output);
}
@Test
void testNullToEmptyGenericEmpty() {
final TestClass[] input = {};
final TestClass[] output = ArrayUtils.nullToEmpty(input, TestClass[].class);
assertSame(input, output);
}
@Test
void testNullToEmptyGenericNull() {
final TestClass[] output = ArrayUtils.nullToEmpty(null, TestClass[].class);
assertNotNull(output);
assertEquals(0, output.length);
}
@Test
void testNullToEmptyGenericNullType() {
final TestClass[] input = {};
assertIllegalArgumentException(() -> ArrayUtils.nullToEmpty(input, null));
}
@Test
void testNullToEmptyInt() {
final int[] original = {1, 2};
assertEquals(original, ArrayUtils.nullToEmpty(original));
}
@Test
void testNullToEmptyIntEmptyArray() {
final int[] empty = {};
final int[] result = ArrayUtils.nullToEmpty(empty);
assertEquals(ArrayUtils.EMPTY_INT_ARRAY, result);
assertNotSame(empty, result);
}
@Test
void testNullToEmptyIntNull() {
assertEquals(ArrayUtils.EMPTY_INT_ARRAY, ArrayUtils.nullToEmpty((int[]) null));
}
@Test
void testNullToEmptyIntObject() {
final Integer[] original = {1, 2};
assertArrayEquals(original, ArrayUtils.nullToEmpty(original));
}
@Test
void testNullToEmptyIntObjectEmptyArray() {
final Integer[] empty = {};
final Integer[] result = ArrayUtils.nullToEmpty(empty);
assertArrayEquals(ArrayUtils.EMPTY_INTEGER_OBJECT_ARRAY, result);
assertNotSame(empty, result);
}
@Test
void testNullToEmptyIntObjectNull() {
assertArrayEquals(ArrayUtils.EMPTY_INTEGER_OBJECT_ARRAY, ArrayUtils.nullToEmpty((Integer[]) null));
}
@Test
void testNullToEmptyLong() {
final long[] original = {1L, 2L};
assertEquals(original, ArrayUtils.nullToEmpty(original));
}
@Test
void testNullToEmptyLongEmptyArray() {
final long[] empty = {};
final long[] result = ArrayUtils.nullToEmpty(empty);
assertEquals(ArrayUtils.EMPTY_LONG_ARRAY, result);
assertNotSame(empty, result);
}
@Test
void testNullToEmptyLongNull() {
assertEquals(ArrayUtils.EMPTY_LONG_ARRAY, ArrayUtils.nullToEmpty((long[]) null));
}
@Test
void testNullToEmptyLongObject() {
@SuppressWarnings("boxing") final Long[] original = {1L, 2L};
assertArrayEquals(original, ArrayUtils.nullToEmpty(original));
}
@Test
void testNullToEmptyLongObjectEmptyArray() {
final Long[] empty = {};
final Long[] result = ArrayUtils.nullToEmpty(empty);
assertArrayEquals(ArrayUtils.EMPTY_LONG_OBJECT_ARRAY, result);
assertNotSame(empty, result);
}
@Test
void testNullToEmptyLongObjectNull() {
assertArrayEquals(ArrayUtils.EMPTY_LONG_OBJECT_ARRAY, ArrayUtils.nullToEmpty((Long[]) null));
}
@Test
void testNullToEmptyObject() {
final Object[] original = {Boolean.TRUE, Boolean.FALSE};
assertArrayEquals(original, ArrayUtils.nullToEmpty(original));
}
@Test
void testNullToEmptyObjectEmptyArray() {
final Object[] empty = {};
final Object[] result = ArrayUtils.nullToEmpty(empty);
assertArrayEquals(ArrayUtils.EMPTY_OBJECT_ARRAY, result);
assertNotSame(empty, result);
}
@Test
void testNullToEmptyObjectNull() {
assertArrayEquals(ArrayUtils.EMPTY_OBJECT_ARRAY, ArrayUtils.nullToEmpty((Object[]) null));
}
@Test
void testNullToEmptyShort() {
final short[] original = {1, 2};
assertEquals(original, ArrayUtils.nullToEmpty(original));
}
@Test
void testNullToEmptyShortEmptyArray() {
final short[] empty = {};
final short[] result = ArrayUtils.nullToEmpty(empty);
assertEquals(ArrayUtils.EMPTY_SHORT_ARRAY, result);
assertNotSame(empty, result);
}
@Test
void testNullToEmptyShortNull() {
assertEquals(ArrayUtils.EMPTY_SHORT_ARRAY, ArrayUtils.nullToEmpty((short[]) null));
}
@Test
void testNullToEmptyShortObject() {
@SuppressWarnings("boxing") final Short[] original = {1, 2};
assertArrayEquals(original, ArrayUtils.nullToEmpty(original));
}
@Test
void testNullToEmptyShortObjectEmptyArray() {
final Short[] empty = {};
final Short[] result = ArrayUtils.nullToEmpty(empty);
assertArrayEquals(ArrayUtils.EMPTY_SHORT_OBJECT_ARRAY, result);
assertNotSame(empty, result);
}
@Test
void testNullToEmptyShortObjectNull() {
assertArrayEquals(ArrayUtils.EMPTY_SHORT_OBJECT_ARRAY, ArrayUtils.nullToEmpty((Short[]) null));
}
@Test
void testNullToEmptyString() {
final String[] original = {"abc", "def"};
assertArrayEquals(original, ArrayUtils.nullToEmpty(original));
}
@Test
void testNullToEmptyStringEmptyArray() {
final String[] empty = {};
final String[] result = ArrayUtils.nullToEmpty(empty);
assertArrayEquals(ArrayUtils.EMPTY_STRING_ARRAY, result);
assertNotSame(empty, result);
}
@Test
void testNullToEmptyStringNull() {
assertArrayEquals(ArrayUtils.EMPTY_STRING_ARRAY, ArrayUtils.nullToEmpty((String[]) null));
}
@Test
void testNullToShortObject() {
@SuppressWarnings("boxing") final Short[] original = {1, 2};
assertArrayEquals(original, ArrayUtils.nullTo(original, ArrayUtils.EMPTY_SHORT_OBJECT_ARRAY));
}
@Test
void testReverse() {
final StringBuffer str1 = new StringBuffer("pick");
final String str2 = "a";
final String[] str3 = {"stick"};
final String str4 = "up";
Object[] array = {str1, str2, str3};
ArrayUtils.reverse(array);
assertEquals(array[0], str3);
assertEquals(array[1], str2);
assertEquals(array[2], str1);
array = new Object[]{str1, str2, str3, str4};
ArrayUtils.reverse(array);
assertEquals(array[0], str4);
assertEquals(array[1], str3);
assertEquals(array[2], str2);
assertEquals(array[3], str1);
array = null;
ArrayUtils.reverse(array);
assertArrayEquals(null, array);
}
@Test
void testReverseBoolean() {
boolean[] array = {false, false, true};
ArrayUtils.reverse(array);
assertTrue(array[0]);
assertFalse(array[1]);
assertFalse(array[2]);
array = null;
ArrayUtils.reverse(array);
assertNull(array);
}
@Test
void testReverseBooleanRange() {
boolean[] array = {false, false, true};
// The whole array
ArrayUtils.reverse(array, 0, 3);
assertTrue(array[0]);
assertFalse(array[1]);
assertFalse(array[2]);
// a range
array = new boolean[]{false, false, true};
ArrayUtils.reverse(array, 0, 2);
assertFalse(array[0]);
assertFalse(array[1]);
assertTrue(array[2]);
// a range with a negative start
array = new boolean[]{false, false, true};
ArrayUtils.reverse(array, -1, 3);
assertTrue(array[0]);
assertFalse(array[1]);
assertFalse(array[2]);
// a range with a large stop index
array = new boolean[]{false, false, true};
ArrayUtils.reverse(array, -1, array.length + 1000);
assertTrue(array[0]);
assertFalse(array[1]);
assertFalse(array[2]);
// null
array = null;
ArrayUtils.reverse(array, 0, 3);
assertNull(array);
}
@Test
void testReverseByte() {
byte[] array = {2, 3, 4};
ArrayUtils.reverse(array);
assertEquals(4, array[0]);
assertEquals(3, array[1]);
assertEquals(2, array[2]);
array = null;
ArrayUtils.reverse(array);
assertNull(array);
}
@Test
void testReverseByteRange() {
byte[] array = {1, 2, 3};
// The whole array
ArrayUtils.reverse(array, 0, 3);
assertEquals(3, array[0]);
assertEquals(2, array[1]);
assertEquals(1, array[2]);
// a range
array = new byte[]{1, 2, 3};
ArrayUtils.reverse(array, 0, 2);
assertEquals(2, array[0]);
assertEquals(1, array[1]);
assertEquals(3, array[2]);
// a range with a negative start
array = new byte[]{1, 2, 3};
ArrayUtils.reverse(array, -1, 3);
assertEquals(3, array[0]);
assertEquals(2, array[1]);
assertEquals(1, array[2]);
// a range with a large stop index
array = new byte[]{1, 2, 3};
ArrayUtils.reverse(array, -1, array.length + 1000);
assertEquals(3, array[0]);
assertEquals(2, array[1]);
assertEquals(1, array[2]);
// null
array = null;
ArrayUtils.reverse(array, 0, 3);
assertNull(array);
}
@Test
void testReverseChar() {
char[] array = {'a', 'f', 'C'};
ArrayUtils.reverse(array);
assertEquals('C', array[0]);
assertEquals('f', array[1]);
assertEquals('a', array[2]);
array = null;
ArrayUtils.reverse(array);
assertNull(array);
}
@Test
void testReverseCharRange() {
char[] array = {1, 2, 3};
// The whole array
ArrayUtils.reverse(array, 0, 3);
assertEquals(3, array[0]);
assertEquals(2, array[1]);
assertEquals(1, array[2]);
// a range
array = new char[]{1, 2, 3};
ArrayUtils.reverse(array, 0, 2);
assertEquals(2, array[0]);
assertEquals(1, array[1]);
assertEquals(3, array[2]);
// a range with a negative start
array = new char[]{1, 2, 3};
ArrayUtils.reverse(array, -1, 3);
assertEquals(3, array[0]);
assertEquals(2, array[1]);
assertEquals(1, array[2]);
// a range with a large stop index
array = new char[]{1, 2, 3};
ArrayUtils.reverse(array, -1, array.length + 1000);
assertEquals(3, array[0]);
assertEquals(2, array[1]);
assertEquals(1, array[2]);
// null
array = null;
ArrayUtils.reverse(array, 0, 3);
assertNull(array);
}
@Test
void testReverseDouble() {
double[] array = {0.3d, 0.4d, 0.5d};
ArrayUtils.reverse(array);
assertEquals(0.5d, array[0]);
assertEquals(0.4d, array[1]);
assertEquals(0.3d, array[2]);
array = null;
ArrayUtils.reverse(array);
assertNull(array);
}
@Test
void testReverseDoubleRange() {
double[] array = {1, 2, 3};
// The whole array
ArrayUtils.reverse(array, 0, 3);
assertEquals(3, array[0]);
assertEquals(2, array[1]);
assertEquals(1, array[2]);
// a range
array = new double[]{1, 2, 3};
ArrayUtils.reverse(array, 0, 2);
assertEquals(2, array[0]);
assertEquals(1, array[1]);
assertEquals(3, array[2]);
// a range with a negative start
array = new double[]{1, 2, 3};
ArrayUtils.reverse(array, -1, 3);
assertEquals(3, array[0]);
assertEquals(2, array[1]);
assertEquals(1, array[2]);
// a range with a large stop index
array = new double[]{1, 2, 3};
ArrayUtils.reverse(array, -1, array.length + 1000);
assertEquals(3, array[0]);
assertEquals(2, array[1]);
assertEquals(1, array[2]);
// null
array = null;
ArrayUtils.reverse(array, 0, 3);
assertNull(array);
}
@Test
void testReverseFloat() {
float[] array = {0.3f, 0.4f, 0.5f};
ArrayUtils.reverse(array);
assertEquals(0.5f, array[0]);
assertEquals(0.4f, array[1]);
assertEquals(0.3f, array[2]);
array = null;
ArrayUtils.reverse(array);
assertNull(array);
}
@Test
void testReverseFloatRange() {
float[] array = {1, 2, 3};
// The whole array
ArrayUtils.reverse(array, 0, 3);
assertEquals(3, array[0]);
assertEquals(2, array[1]);
assertEquals(1, array[2]);
// a range
array = new float[]{1, 2, 3};
ArrayUtils.reverse(array, 0, 2);
assertEquals(2, array[0]);
assertEquals(1, array[1]);
assertEquals(3, array[2]);
// a range with a negative start
array = new float[]{1, 2, 3};
ArrayUtils.reverse(array, -1, 3);
assertEquals(3, array[0]);
assertEquals(2, array[1]);
assertEquals(1, array[2]);
// a range with a large stop index
array = new float[]{1, 2, 3};
ArrayUtils.reverse(array, -1, array.length + 1000);
assertEquals(3, array[0]);
assertEquals(2, array[1]);
assertEquals(1, array[2]);
// null
array = null;
ArrayUtils.reverse(array, 0, 3);
assertNull(array);
}
@Test
void testReverseInt() {
int[] array = {1, 2, 3};
ArrayUtils.reverse(array);
assertEquals(3, array[0]);
assertEquals(2, array[1]);
assertEquals(1, array[2]);
array = null;
ArrayUtils.reverse(array);
assertNull(array);
}
@Test
void testReverseIntRange() {
int[] array = {1, 2, 3};
// The whole array
ArrayUtils.reverse(array, 0, 3);
assertEquals(3, array[0]);
assertEquals(2, array[1]);
assertEquals(1, array[2]);
// a range
array = new int[]{1, 2, 3};
ArrayUtils.reverse(array, 0, 2);
assertEquals(2, array[0]);
assertEquals(1, array[1]);
assertEquals(3, array[2]);
// a range with a negative start
array = new int[]{1, 2, 3};
ArrayUtils.reverse(array, -1, 3);
assertEquals(3, array[0]);
assertEquals(2, array[1]);
assertEquals(1, array[2]);
// a range with a large stop index
array = new int[]{1, 2, 3};
ArrayUtils.reverse(array, -1, array.length + 1000);
assertEquals(3, array[0]);
assertEquals(2, array[1]);
assertEquals(1, array[2]);
// null
array = null;
ArrayUtils.reverse(array, 0, 3);
assertNull(array);
}
@Test
void testReverseLong() {
long[] array = {1L, 2L, 3L};
ArrayUtils.reverse(array);
assertEquals(3L, array[0]);
assertEquals(2L, array[1]);
assertEquals(1L, array[2]);
array = null;
ArrayUtils.reverse(array);
assertNull(array);
}
@Test
void testReverseLongRange() {
long[] array = {1, 2, 3};
// The whole array
ArrayUtils.reverse(array, 0, 3);
assertEquals(3, array[0]);
assertEquals(2, array[1]);
assertEquals(1, array[2]);
// a range
array = new long[]{1, 2, 3};
ArrayUtils.reverse(array, 0, 2);
assertEquals(2, array[0]);
assertEquals(1, array[1]);
assertEquals(3, array[2]);
// a range with a negative start
array = new long[]{1, 2, 3};
ArrayUtils.reverse(array, -1, 3);
assertEquals(3, array[0]);
assertEquals(2, array[1]);
assertEquals(1, array[2]);
// a range with a large stop index
array = new long[]{1, 2, 3};
ArrayUtils.reverse(array, -1, array.length + 1000);
assertEquals(3, array[0]);
assertEquals(2, array[1]);
assertEquals(1, array[2]);
// null
array = null;
ArrayUtils.reverse(array, 0, 3);
assertNull(array);
}
@Test
void testReverseObjectRange() {
String[] array = {"1", "2", "3"};
// The whole array
ArrayUtils.reverse(array, 0, 3);
assertEquals("3", array[0]);
assertEquals("2", array[1]);
assertEquals("1", array[2]);
// a range
array = new String[]{"1", "2", "3"};
ArrayUtils.reverse(array, 0, 2);
assertEquals("2", array[0]);
assertEquals("1", array[1]);
assertEquals("3", array[2]);
// a range with a negative start
array = new String[]{"1", "2", "3"};
ArrayUtils.reverse(array, -1, 3);
assertEquals("3", array[0]);
assertEquals("2", array[1]);
assertEquals("1", array[2]);
// a range with a large stop index
array = new String[]{"1", "2", "3"};
ArrayUtils.reverse(array, -1, array.length + 1000);
assertEquals("3", array[0]);
assertEquals("2", array[1]);
assertEquals("1", array[2]);
// null
array = null;
ArrayUtils.reverse(array, 0, 3);
assertNull(array);
}
@Test
void testReverseShort() {
short[] array = {1, 2, 3};
ArrayUtils.reverse(array);
assertEquals(3, array[0]);
assertEquals(2, array[1]);
assertEquals(1, array[2]);
array = null;
ArrayUtils.reverse(array);
assertNull(array);
}
@Test
void testReverseShortRange() {
short[] array = {1, 2, 3};
// The whole array
ArrayUtils.reverse(array, 0, 3);
assertEquals(3, array[0]);
assertEquals(2, array[1]);
assertEquals(1, array[2]);
// a range
array = new short[]{1, 2, 3};
ArrayUtils.reverse(array, 0, 2);
assertEquals(2, array[0]);
assertEquals(1, array[1]);
assertEquals(3, array[2]);
// a range with a negative start
array = new short[]{1, 2, 3};
ArrayUtils.reverse(array, -1, 3);
assertEquals(3, array[0]);
assertEquals(2, array[1]);
assertEquals(1, array[2]);
// a range with a large stop index
array = new short[]{1, 2, 3};
ArrayUtils.reverse(array, -1, array.length + 1000);
assertEquals(3, array[0]);
assertEquals(2, array[1]);
assertEquals(1, array[2]);
// null
array = null;
ArrayUtils.reverse(array, 0, 3);
assertNull(array);
}
@Test
void testSameLength() {
final Object[] nullArray = null;
final Object[] emptyArray = {};
final Object[] oneArray = {"pick"};
final Object[] twoArray = {"pick", "stick"};
assertTrue(ArrayUtils.isSameLength(nullArray, nullArray));
assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray));
assertFalse(ArrayUtils.isSameLength(nullArray, oneArray));
assertFalse(ArrayUtils.isSameLength(nullArray, twoArray));
assertTrue(ArrayUtils.isSameLength(emptyArray, nullArray));
assertTrue(ArrayUtils.isSameLength(emptyArray, emptyArray));
assertFalse(ArrayUtils.isSameLength(emptyArray, oneArray));
assertFalse(ArrayUtils.isSameLength(emptyArray, twoArray));
assertFalse(ArrayUtils.isSameLength(oneArray, nullArray));
assertFalse(ArrayUtils.isSameLength(oneArray, emptyArray));
assertTrue(ArrayUtils.isSameLength(oneArray, oneArray));
assertFalse(ArrayUtils.isSameLength(oneArray, twoArray));
assertFalse(ArrayUtils.isSameLength(twoArray, nullArray));
assertFalse(ArrayUtils.isSameLength(twoArray, emptyArray));
assertFalse(ArrayUtils.isSameLength(twoArray, oneArray));
assertTrue(ArrayUtils.isSameLength(twoArray, twoArray));
}
@Test
void testSameLengthAll() {
final Object[] nullArrayObject = null;
final Object[] emptyArrayObject = {};
final Object[] oneArrayObject = {"pick"};
final Object[] twoArrayObject = {"pick", "stick"};
final boolean[] nullArrayBoolean = null;
final boolean[] emptyArrayBoolean = {};
final boolean[] oneArrayBoolean = {true};
final boolean[] twoArrayBoolean = {true, false};
final long[] nullArrayLong = null;
final long[] emptyArrayLong = {};
final long[] oneArrayLong = {0L};
final long[] twoArrayLong = {0L, 76L};
final int[] nullArrayInt = null;
final int[] emptyArrayInt = {};
final int[] oneArrayInt = {4};
final int[] twoArrayInt = {5, 7};
final short[] nullArrayShort = null;
final short[] emptyArrayShort = {};
final short[] oneArrayShort = {4};
final short[] twoArrayShort = {6, 8};
final char[] nullArrayChar = null;
final char[] emptyArrayChar = {};
final char[] oneArrayChar = {'f'};
final char[] twoArrayChar = {'d', 't'};
final byte[] nullArrayByte = null;
final byte[] emptyArrayByte = {};
final byte[] oneArrayByte = {3};
final byte[] twoArrayByte = {4, 6};
final double[] nullArrayDouble = null;
final double[] emptyArrayDouble = {};
final double[] oneArrayDouble = {1.3d};
final double[] twoArrayDouble = {4.5d, 6.3d};
final float[] nullArrayFloat = null;
final float[] emptyArrayFloat = {};
final float[] oneArrayFloat = {2.5f};
final float[] twoArrayFloat = {6.4f, 5.8f};
assertTrue(ArrayUtils.isSameLength(nullArrayObject, nullArrayObject));
assertTrue(ArrayUtils.isSameLength(nullArrayObject, nullArrayBoolean));
assertTrue(ArrayUtils.isSameLength(nullArrayObject, nullArrayLong));
assertTrue(ArrayUtils.isSameLength(nullArrayObject, nullArrayInt));
assertTrue(ArrayUtils.isSameLength(nullArrayObject, nullArrayShort));
assertTrue(ArrayUtils.isSameLength(nullArrayObject, nullArrayChar));
assertTrue(ArrayUtils.isSameLength(nullArrayObject, nullArrayByte));
assertTrue(ArrayUtils.isSameLength(nullArrayObject, nullArrayDouble));
assertTrue(ArrayUtils.isSameLength(nullArrayObject, nullArrayFloat));
assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, nullArrayObject));
assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, nullArrayBoolean));
assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, nullArrayLong));
assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, nullArrayInt));
assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, nullArrayShort));
assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, nullArrayChar));
assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, nullArrayByte));
assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, nullArrayDouble));
assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, nullArrayFloat));
assertTrue(ArrayUtils.isSameLength(nullArrayLong, nullArrayObject));
assertTrue(ArrayUtils.isSameLength(nullArrayLong, nullArrayBoolean));
assertTrue(ArrayUtils.isSameLength(nullArrayLong, nullArrayLong));
assertTrue(ArrayUtils.isSameLength(nullArrayLong, nullArrayInt));
assertTrue(ArrayUtils.isSameLength(nullArrayLong, nullArrayShort));
assertTrue(ArrayUtils.isSameLength(nullArrayLong, nullArrayChar));
assertTrue(ArrayUtils.isSameLength(nullArrayLong, nullArrayByte));
assertTrue(ArrayUtils.isSameLength(nullArrayLong, nullArrayDouble));
assertTrue(ArrayUtils.isSameLength(nullArrayLong, nullArrayFloat));
assertTrue(ArrayUtils.isSameLength(nullArrayInt, nullArrayObject));
assertTrue(ArrayUtils.isSameLength(nullArrayInt, nullArrayBoolean));
assertTrue(ArrayUtils.isSameLength(nullArrayInt, nullArrayLong));
assertTrue(ArrayUtils.isSameLength(nullArrayInt, nullArrayInt));
assertTrue(ArrayUtils.isSameLength(nullArrayInt, nullArrayShort));
assertTrue(ArrayUtils.isSameLength(nullArrayInt, nullArrayChar));
assertTrue(ArrayUtils.isSameLength(nullArrayInt, nullArrayByte));
assertTrue(ArrayUtils.isSameLength(nullArrayInt, nullArrayDouble));
assertTrue(ArrayUtils.isSameLength(nullArrayInt, nullArrayFloat));
assertTrue(ArrayUtils.isSameLength(nullArrayShort, nullArrayObject));
assertTrue(ArrayUtils.isSameLength(nullArrayShort, nullArrayBoolean));
assertTrue(ArrayUtils.isSameLength(nullArrayShort, nullArrayLong));
assertTrue(ArrayUtils.isSameLength(nullArrayShort, nullArrayInt));
assertTrue(ArrayUtils.isSameLength(nullArrayShort, nullArrayShort));
assertTrue(ArrayUtils.isSameLength(nullArrayShort, nullArrayChar));
assertTrue(ArrayUtils.isSameLength(nullArrayShort, nullArrayByte));
assertTrue(ArrayUtils.isSameLength(nullArrayShort, nullArrayDouble));
assertTrue(ArrayUtils.isSameLength(nullArrayShort, nullArrayFloat));
assertTrue(ArrayUtils.isSameLength(nullArrayChar, nullArrayObject));
assertTrue(ArrayUtils.isSameLength(nullArrayChar, nullArrayBoolean));
assertTrue(ArrayUtils.isSameLength(nullArrayChar, nullArrayLong));
assertTrue(ArrayUtils.isSameLength(nullArrayChar, nullArrayInt));
assertTrue(ArrayUtils.isSameLength(nullArrayChar, nullArrayShort));
assertTrue(ArrayUtils.isSameLength(nullArrayChar, nullArrayChar));
assertTrue(ArrayUtils.isSameLength(nullArrayChar, nullArrayByte));
assertTrue(ArrayUtils.isSameLength(nullArrayChar, nullArrayDouble));
assertTrue(ArrayUtils.isSameLength(nullArrayChar, nullArrayFloat));
assertTrue(ArrayUtils.isSameLength(nullArrayByte, nullArrayObject));
assertTrue(ArrayUtils.isSameLength(nullArrayByte, nullArrayBoolean));
assertTrue(ArrayUtils.isSameLength(nullArrayByte, nullArrayLong));
assertTrue(ArrayUtils.isSameLength(nullArrayByte, nullArrayInt));
assertTrue(ArrayUtils.isSameLength(nullArrayByte, nullArrayShort));
assertTrue(ArrayUtils.isSameLength(nullArrayByte, nullArrayChar));
assertTrue(ArrayUtils.isSameLength(nullArrayByte, nullArrayByte));
assertTrue(ArrayUtils.isSameLength(nullArrayByte, nullArrayDouble));
assertTrue(ArrayUtils.isSameLength(nullArrayByte, nullArrayFloat));
assertTrue(ArrayUtils.isSameLength(nullArrayDouble, nullArrayObject));
assertTrue(ArrayUtils.isSameLength(nullArrayDouble, nullArrayBoolean));
assertTrue(ArrayUtils.isSameLength(nullArrayDouble, nullArrayLong));
assertTrue(ArrayUtils.isSameLength(nullArrayDouble, nullArrayInt));
assertTrue(ArrayUtils.isSameLength(nullArrayDouble, nullArrayShort));
assertTrue(ArrayUtils.isSameLength(nullArrayDouble, nullArrayChar));
assertTrue(ArrayUtils.isSameLength(nullArrayDouble, nullArrayByte));
assertTrue(ArrayUtils.isSameLength(nullArrayDouble, nullArrayDouble));
assertTrue(ArrayUtils.isSameLength(nullArrayDouble, nullArrayFloat));
assertTrue(ArrayUtils.isSameLength(nullArrayFloat, nullArrayObject));
assertTrue(ArrayUtils.isSameLength(nullArrayFloat, nullArrayBoolean));
assertTrue(ArrayUtils.isSameLength(nullArrayFloat, nullArrayLong));
assertTrue(ArrayUtils.isSameLength(nullArrayFloat, nullArrayInt));
assertTrue(ArrayUtils.isSameLength(nullArrayFloat, nullArrayShort));
assertTrue(ArrayUtils.isSameLength(nullArrayFloat, nullArrayChar));
assertTrue(ArrayUtils.isSameLength(nullArrayFloat, nullArrayByte));
assertTrue(ArrayUtils.isSameLength(nullArrayFloat, nullArrayDouble));
assertTrue(ArrayUtils.isSameLength(nullArrayFloat, nullArrayFloat));
assertTrue(ArrayUtils.isSameLength(nullArrayObject, emptyArrayObject));
assertTrue(ArrayUtils.isSameLength(nullArrayObject, emptyArrayBoolean));
assertTrue(ArrayUtils.isSameLength(nullArrayObject, emptyArrayLong));
assertTrue(ArrayUtils.isSameLength(nullArrayObject, emptyArrayInt));
assertTrue(ArrayUtils.isSameLength(nullArrayObject, emptyArrayShort));
assertTrue(ArrayUtils.isSameLength(nullArrayObject, emptyArrayChar));
assertTrue(ArrayUtils.isSameLength(nullArrayObject, emptyArrayByte));
assertTrue(ArrayUtils.isSameLength(nullArrayObject, emptyArrayDouble));
assertTrue(ArrayUtils.isSameLength(nullArrayObject, emptyArrayFloat));
assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, emptyArrayObject));
assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, emptyArrayBoolean));
assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, emptyArrayLong));
assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, emptyArrayInt));
assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, emptyArrayShort));
assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, emptyArrayChar));
assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, emptyArrayByte));
assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, emptyArrayDouble));
assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, emptyArrayFloat));
assertTrue(ArrayUtils.isSameLength(nullArrayLong, emptyArrayObject));
assertTrue(ArrayUtils.isSameLength(nullArrayLong, emptyArrayBoolean));
assertTrue(ArrayUtils.isSameLength(nullArrayLong, emptyArrayLong));
assertTrue(ArrayUtils.isSameLength(nullArrayLong, emptyArrayInt));
assertTrue(ArrayUtils.isSameLength(nullArrayLong, emptyArrayShort));
assertTrue(ArrayUtils.isSameLength(nullArrayLong, emptyArrayChar));
assertTrue(ArrayUtils.isSameLength(nullArrayLong, emptyArrayByte));
assertTrue(ArrayUtils.isSameLength(nullArrayLong, emptyArrayDouble));
assertTrue(ArrayUtils.isSameLength(nullArrayLong, emptyArrayFloat));
assertTrue(ArrayUtils.isSameLength(nullArrayInt, emptyArrayObject));
assertTrue(ArrayUtils.isSameLength(nullArrayInt, emptyArrayBoolean));
assertTrue(ArrayUtils.isSameLength(nullArrayInt, emptyArrayLong));
assertTrue(ArrayUtils.isSameLength(nullArrayInt, emptyArrayInt));
assertTrue(ArrayUtils.isSameLength(nullArrayInt, emptyArrayShort));
assertTrue(ArrayUtils.isSameLength(nullArrayInt, emptyArrayChar));
assertTrue(ArrayUtils.isSameLength(nullArrayInt, emptyArrayByte));
assertTrue(ArrayUtils.isSameLength(nullArrayInt, emptyArrayDouble));
assertTrue(ArrayUtils.isSameLength(nullArrayInt, emptyArrayFloat));
assertTrue(ArrayUtils.isSameLength(nullArrayShort, emptyArrayObject));
assertTrue(ArrayUtils.isSameLength(nullArrayShort, emptyArrayBoolean));
assertTrue(ArrayUtils.isSameLength(nullArrayShort, emptyArrayLong));
assertTrue(ArrayUtils.isSameLength(nullArrayShort, emptyArrayInt));
assertTrue(ArrayUtils.isSameLength(nullArrayShort, emptyArrayShort));
assertTrue(ArrayUtils.isSameLength(nullArrayShort, emptyArrayChar));
assertTrue(ArrayUtils.isSameLength(nullArrayShort, emptyArrayByte));
assertTrue(ArrayUtils.isSameLength(nullArrayShort, emptyArrayDouble));
assertTrue(ArrayUtils.isSameLength(nullArrayShort, emptyArrayFloat));
assertTrue(ArrayUtils.isSameLength(nullArrayChar, emptyArrayObject));
assertTrue(ArrayUtils.isSameLength(nullArrayChar, emptyArrayBoolean));
assertTrue(ArrayUtils.isSameLength(nullArrayChar, emptyArrayLong));
assertTrue(ArrayUtils.isSameLength(nullArrayChar, emptyArrayInt));
assertTrue(ArrayUtils.isSameLength(nullArrayChar, emptyArrayShort));
assertTrue(ArrayUtils.isSameLength(nullArrayChar, emptyArrayChar));
assertTrue(ArrayUtils.isSameLength(nullArrayChar, emptyArrayByte));
assertTrue(ArrayUtils.isSameLength(nullArrayChar, emptyArrayDouble));
assertTrue(ArrayUtils.isSameLength(nullArrayChar, emptyArrayFloat));
assertTrue(ArrayUtils.isSameLength(nullArrayByte, emptyArrayObject));
assertTrue(ArrayUtils.isSameLength(nullArrayByte, emptyArrayBoolean));
assertTrue(ArrayUtils.isSameLength(nullArrayByte, emptyArrayLong));
assertTrue(ArrayUtils.isSameLength(nullArrayByte, emptyArrayInt));
assertTrue(ArrayUtils.isSameLength(nullArrayByte, emptyArrayShort));
assertTrue(ArrayUtils.isSameLength(nullArrayByte, emptyArrayChar));
assertTrue(ArrayUtils.isSameLength(nullArrayByte, emptyArrayByte));
assertTrue(ArrayUtils.isSameLength(nullArrayByte, emptyArrayDouble));
assertTrue(ArrayUtils.isSameLength(nullArrayByte, emptyArrayFloat));
assertTrue(ArrayUtils.isSameLength(nullArrayDouble, emptyArrayObject));
assertTrue(ArrayUtils.isSameLength(nullArrayDouble, emptyArrayBoolean));
assertTrue(ArrayUtils.isSameLength(nullArrayDouble, emptyArrayLong));
assertTrue(ArrayUtils.isSameLength(nullArrayDouble, emptyArrayInt));
assertTrue(ArrayUtils.isSameLength(nullArrayDouble, emptyArrayShort));
assertTrue(ArrayUtils.isSameLength(nullArrayDouble, emptyArrayChar));
assertTrue(ArrayUtils.isSameLength(nullArrayDouble, emptyArrayByte));
assertTrue(ArrayUtils.isSameLength(nullArrayDouble, emptyArrayDouble));
assertTrue(ArrayUtils.isSameLength(nullArrayDouble, emptyArrayFloat));
assertTrue(ArrayUtils.isSameLength(nullArrayFloat, emptyArrayObject));
assertTrue(ArrayUtils.isSameLength(nullArrayFloat, emptyArrayBoolean));
assertTrue(ArrayUtils.isSameLength(nullArrayFloat, emptyArrayLong));
assertTrue(ArrayUtils.isSameLength(nullArrayFloat, emptyArrayInt));
assertTrue(ArrayUtils.isSameLength(nullArrayFloat, emptyArrayShort));
assertTrue(ArrayUtils.isSameLength(nullArrayFloat, emptyArrayChar));
assertTrue(ArrayUtils.isSameLength(nullArrayFloat, emptyArrayByte));
assertTrue(ArrayUtils.isSameLength(nullArrayFloat, emptyArrayDouble));
assertTrue(ArrayUtils.isSameLength(nullArrayFloat, emptyArrayFloat));
assertFalse(ArrayUtils.isSameLength(nullArrayObject, oneArrayObject));
assertFalse(ArrayUtils.isSameLength(nullArrayObject, oneArrayBoolean));
assertFalse(ArrayUtils.isSameLength(nullArrayObject, oneArrayLong));
assertFalse(ArrayUtils.isSameLength(nullArrayObject, oneArrayInt));
assertFalse(ArrayUtils.isSameLength(nullArrayObject, oneArrayShort));
assertFalse(ArrayUtils.isSameLength(nullArrayObject, oneArrayChar));
assertFalse(ArrayUtils.isSameLength(nullArrayObject, oneArrayByte));
assertFalse(ArrayUtils.isSameLength(nullArrayObject, oneArrayDouble));
assertFalse(ArrayUtils.isSameLength(nullArrayObject, oneArrayFloat));
assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, oneArrayObject));
assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, oneArrayBoolean));
assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, oneArrayLong));
assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, oneArrayInt));
assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, oneArrayShort));
assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, oneArrayChar));
assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, oneArrayByte));
assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, oneArrayDouble));
assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, oneArrayFloat));
assertFalse(ArrayUtils.isSameLength(nullArrayLong, oneArrayObject));
assertFalse(ArrayUtils.isSameLength(nullArrayLong, oneArrayBoolean));
assertFalse(ArrayUtils.isSameLength(nullArrayLong, oneArrayLong));
assertFalse(ArrayUtils.isSameLength(nullArrayLong, oneArrayInt));
assertFalse(ArrayUtils.isSameLength(nullArrayLong, oneArrayShort));
assertFalse(ArrayUtils.isSameLength(nullArrayLong, oneArrayChar));
assertFalse(ArrayUtils.isSameLength(nullArrayLong, oneArrayByte));
assertFalse(ArrayUtils.isSameLength(nullArrayLong, oneArrayDouble));
assertFalse(ArrayUtils.isSameLength(nullArrayLong, oneArrayFloat));
assertFalse(ArrayUtils.isSameLength(nullArrayInt, oneArrayObject));
assertFalse(ArrayUtils.isSameLength(nullArrayInt, oneArrayBoolean));
assertFalse(ArrayUtils.isSameLength(nullArrayInt, oneArrayLong));
assertFalse(ArrayUtils.isSameLength(nullArrayInt, oneArrayInt));
assertFalse(ArrayUtils.isSameLength(nullArrayInt, oneArrayShort));
assertFalse(ArrayUtils.isSameLength(nullArrayInt, oneArrayChar));
assertFalse(ArrayUtils.isSameLength(nullArrayInt, oneArrayByte));
assertFalse(ArrayUtils.isSameLength(nullArrayInt, oneArrayDouble));
assertFalse(ArrayUtils.isSameLength(nullArrayInt, oneArrayFloat));
assertFalse(ArrayUtils.isSameLength(nullArrayShort, oneArrayObject));
assertFalse(ArrayUtils.isSameLength(nullArrayShort, oneArrayBoolean));
assertFalse(ArrayUtils.isSameLength(nullArrayShort, oneArrayLong));
assertFalse(ArrayUtils.isSameLength(nullArrayShort, oneArrayInt));
assertFalse(ArrayUtils.isSameLength(nullArrayShort, oneArrayShort));
assertFalse(ArrayUtils.isSameLength(nullArrayShort, oneArrayChar));
assertFalse(ArrayUtils.isSameLength(nullArrayShort, oneArrayByte));
assertFalse(ArrayUtils.isSameLength(nullArrayShort, oneArrayDouble));
assertFalse(ArrayUtils.isSameLength(nullArrayShort, oneArrayFloat));
assertFalse(ArrayUtils.isSameLength(nullArrayChar, oneArrayObject));
assertFalse(ArrayUtils.isSameLength(nullArrayChar, oneArrayBoolean));
assertFalse(ArrayUtils.isSameLength(nullArrayChar, oneArrayLong));
assertFalse(ArrayUtils.isSameLength(nullArrayChar, oneArrayInt));
assertFalse(ArrayUtils.isSameLength(nullArrayChar, oneArrayShort));
assertFalse(ArrayUtils.isSameLength(nullArrayChar, oneArrayChar));
assertFalse(ArrayUtils.isSameLength(nullArrayChar, oneArrayByte));
assertFalse(ArrayUtils.isSameLength(nullArrayChar, oneArrayDouble));
assertFalse(ArrayUtils.isSameLength(nullArrayChar, oneArrayFloat));
assertFalse(ArrayUtils.isSameLength(nullArrayByte, oneArrayObject));
assertFalse(ArrayUtils.isSameLength(nullArrayByte, oneArrayBoolean));
assertFalse(ArrayUtils.isSameLength(nullArrayByte, oneArrayLong));
assertFalse(ArrayUtils.isSameLength(nullArrayByte, oneArrayInt));
assertFalse(ArrayUtils.isSameLength(nullArrayByte, oneArrayShort));
assertFalse(ArrayUtils.isSameLength(nullArrayByte, oneArrayChar));
assertFalse(ArrayUtils.isSameLength(nullArrayByte, oneArrayByte));
assertFalse(ArrayUtils.isSameLength(nullArrayByte, oneArrayDouble));
assertFalse(ArrayUtils.isSameLength(nullArrayByte, oneArrayFloat));
assertFalse(ArrayUtils.isSameLength(nullArrayDouble, oneArrayObject));
assertFalse(ArrayUtils.isSameLength(nullArrayDouble, oneArrayBoolean));
assertFalse(ArrayUtils.isSameLength(nullArrayDouble, oneArrayLong));
assertFalse(ArrayUtils.isSameLength(nullArrayDouble, oneArrayInt));
assertFalse(ArrayUtils.isSameLength(nullArrayDouble, oneArrayShort));
assertFalse(ArrayUtils.isSameLength(nullArrayDouble, oneArrayChar));
assertFalse(ArrayUtils.isSameLength(nullArrayDouble, oneArrayByte));
assertFalse(ArrayUtils.isSameLength(nullArrayDouble, oneArrayDouble));
assertFalse(ArrayUtils.isSameLength(nullArrayDouble, oneArrayFloat));
assertFalse(ArrayUtils.isSameLength(nullArrayFloat, oneArrayObject));
assertFalse(ArrayUtils.isSameLength(nullArrayFloat, oneArrayBoolean));
assertFalse(ArrayUtils.isSameLength(nullArrayFloat, oneArrayLong));
assertFalse(ArrayUtils.isSameLength(nullArrayFloat, oneArrayInt));
assertFalse(ArrayUtils.isSameLength(nullArrayFloat, oneArrayShort));
assertFalse(ArrayUtils.isSameLength(nullArrayFloat, oneArrayChar));
assertFalse(ArrayUtils.isSameLength(nullArrayFloat, oneArrayByte));
assertFalse(ArrayUtils.isSameLength(nullArrayFloat, oneArrayDouble));
assertFalse(ArrayUtils.isSameLength(nullArrayFloat, oneArrayFloat));
assertFalse(ArrayUtils.isSameLength(nullArrayObject, twoArrayObject));
assertFalse(ArrayUtils.isSameLength(nullArrayObject, twoArrayBoolean));
assertFalse(ArrayUtils.isSameLength(nullArrayObject, twoArrayLong));
assertFalse(ArrayUtils.isSameLength(nullArrayObject, twoArrayInt));
assertFalse(ArrayUtils.isSameLength(nullArrayObject, twoArrayShort));
assertFalse(ArrayUtils.isSameLength(nullArrayObject, twoArrayChar));
assertFalse(ArrayUtils.isSameLength(nullArrayObject, twoArrayByte));
assertFalse(ArrayUtils.isSameLength(nullArrayObject, twoArrayDouble));
assertFalse(ArrayUtils.isSameLength(nullArrayObject, twoArrayFloat));
assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, twoArrayObject));
assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, twoArrayBoolean));
assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, twoArrayLong));
assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, twoArrayInt));
assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, twoArrayShort));
assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, twoArrayChar));
assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, twoArrayByte));
assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, twoArrayDouble));
assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, twoArrayFloat));
assertFalse(ArrayUtils.isSameLength(nullArrayLong, twoArrayObject));
assertFalse(ArrayUtils.isSameLength(nullArrayLong, twoArrayBoolean));
assertFalse(ArrayUtils.isSameLength(nullArrayLong, twoArrayLong));
assertFalse(ArrayUtils.isSameLength(nullArrayLong, twoArrayInt));
assertFalse(ArrayUtils.isSameLength(nullArrayLong, twoArrayShort));
assertFalse(ArrayUtils.isSameLength(nullArrayLong, twoArrayChar));
assertFalse(ArrayUtils.isSameLength(nullArrayLong, twoArrayByte));
assertFalse(ArrayUtils.isSameLength(nullArrayLong, twoArrayDouble));
assertFalse(ArrayUtils.isSameLength(nullArrayLong, twoArrayFloat));
assertFalse(ArrayUtils.isSameLength(nullArrayInt, twoArrayObject));
assertFalse(ArrayUtils.isSameLength(nullArrayInt, twoArrayBoolean));
assertFalse(ArrayUtils.isSameLength(nullArrayInt, twoArrayLong));
assertFalse(ArrayUtils.isSameLength(nullArrayInt, twoArrayInt));
assertFalse(ArrayUtils.isSameLength(nullArrayInt, twoArrayShort));
assertFalse(ArrayUtils.isSameLength(nullArrayInt, twoArrayChar));
assertFalse(ArrayUtils.isSameLength(nullArrayInt, twoArrayByte));
assertFalse(ArrayUtils.isSameLength(nullArrayInt, twoArrayDouble));
assertFalse(ArrayUtils.isSameLength(nullArrayInt, twoArrayFloat));
assertFalse(ArrayUtils.isSameLength(nullArrayShort, twoArrayObject));
assertFalse(ArrayUtils.isSameLength(nullArrayShort, twoArrayBoolean));
assertFalse(ArrayUtils.isSameLength(nullArrayShort, twoArrayLong));
assertFalse(ArrayUtils.isSameLength(nullArrayShort, twoArrayInt));
assertFalse(ArrayUtils.isSameLength(nullArrayShort, twoArrayShort));
assertFalse(ArrayUtils.isSameLength(nullArrayShort, twoArrayChar));
assertFalse(ArrayUtils.isSameLength(nullArrayShort, twoArrayByte));
assertFalse(ArrayUtils.isSameLength(nullArrayShort, twoArrayDouble));
assertFalse(ArrayUtils.isSameLength(nullArrayShort, twoArrayFloat));
assertFalse(ArrayUtils.isSameLength(nullArrayChar, twoArrayObject));
assertFalse(ArrayUtils.isSameLength(nullArrayChar, twoArrayBoolean));
assertFalse(ArrayUtils.isSameLength(nullArrayChar, twoArrayLong));
assertFalse(ArrayUtils.isSameLength(nullArrayChar, twoArrayInt));
assertFalse(ArrayUtils.isSameLength(nullArrayChar, twoArrayShort));
assertFalse(ArrayUtils.isSameLength(nullArrayChar, twoArrayChar));
assertFalse(ArrayUtils.isSameLength(nullArrayChar, twoArrayByte));
assertFalse(ArrayUtils.isSameLength(nullArrayChar, twoArrayDouble));
assertFalse(ArrayUtils.isSameLength(nullArrayChar, twoArrayFloat));
assertFalse(ArrayUtils.isSameLength(nullArrayByte, twoArrayObject));
assertFalse(ArrayUtils.isSameLength(nullArrayByte, twoArrayBoolean));
assertFalse(ArrayUtils.isSameLength(nullArrayByte, twoArrayLong));
assertFalse(ArrayUtils.isSameLength(nullArrayByte, twoArrayInt));
assertFalse(ArrayUtils.isSameLength(nullArrayByte, twoArrayShort));
assertFalse(ArrayUtils.isSameLength(nullArrayByte, twoArrayChar));
assertFalse(ArrayUtils.isSameLength(nullArrayByte, twoArrayByte));
assertFalse(ArrayUtils.isSameLength(nullArrayByte, twoArrayDouble));
assertFalse(ArrayUtils.isSameLength(nullArrayByte, twoArrayFloat));
assertFalse(ArrayUtils.isSameLength(nullArrayDouble, twoArrayObject));
assertFalse(ArrayUtils.isSameLength(nullArrayDouble, twoArrayBoolean));
assertFalse(ArrayUtils.isSameLength(nullArrayDouble, twoArrayLong));
assertFalse(ArrayUtils.isSameLength(nullArrayDouble, twoArrayInt));
assertFalse(ArrayUtils.isSameLength(nullArrayDouble, twoArrayShort));
assertFalse(ArrayUtils.isSameLength(nullArrayDouble, twoArrayChar));
assertFalse(ArrayUtils.isSameLength(nullArrayDouble, twoArrayByte));
assertFalse(ArrayUtils.isSameLength(nullArrayDouble, twoArrayDouble));
assertFalse(ArrayUtils.isSameLength(nullArrayDouble, twoArrayFloat));
assertFalse(ArrayUtils.isSameLength(nullArrayFloat, twoArrayObject));
assertFalse(ArrayUtils.isSameLength(nullArrayFloat, twoArrayBoolean));
assertFalse(ArrayUtils.isSameLength(nullArrayFloat, twoArrayLong));
assertFalse(ArrayUtils.isSameLength(nullArrayFloat, twoArrayInt));
assertFalse(ArrayUtils.isSameLength(nullArrayFloat, twoArrayShort));
assertFalse(ArrayUtils.isSameLength(nullArrayFloat, twoArrayChar));
assertFalse(ArrayUtils.isSameLength(nullArrayFloat, twoArrayByte));
assertFalse(ArrayUtils.isSameLength(nullArrayFloat, twoArrayDouble));
assertFalse(ArrayUtils.isSameLength(nullArrayFloat, twoArrayFloat));
assertTrue(ArrayUtils.isSameLength(emptyArrayObject, nullArrayObject));
assertTrue(ArrayUtils.isSameLength(emptyArrayObject, nullArrayBoolean));
assertTrue(ArrayUtils.isSameLength(emptyArrayObject, nullArrayLong));
assertTrue(ArrayUtils.isSameLength(emptyArrayObject, nullArrayInt));
assertTrue(ArrayUtils.isSameLength(emptyArrayObject, nullArrayShort));
assertTrue(ArrayUtils.isSameLength(emptyArrayObject, nullArrayChar));
assertTrue(ArrayUtils.isSameLength(emptyArrayObject, nullArrayByte));
assertTrue(ArrayUtils.isSameLength(emptyArrayObject, nullArrayDouble));
assertTrue(ArrayUtils.isSameLength(emptyArrayObject, nullArrayFloat));
assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, nullArrayObject));
assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, nullArrayBoolean));
assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, nullArrayLong));
assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, nullArrayInt));
assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, nullArrayShort));
assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, nullArrayChar));
assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, nullArrayByte));
assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, nullArrayDouble));
assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, nullArrayFloat));
assertTrue(ArrayUtils.isSameLength(emptyArrayLong, nullArrayObject));
assertTrue(ArrayUtils.isSameLength(emptyArrayLong, nullArrayBoolean));
assertTrue(ArrayUtils.isSameLength(emptyArrayLong, nullArrayLong));
assertTrue(ArrayUtils.isSameLength(emptyArrayLong, nullArrayInt));
assertTrue(ArrayUtils.isSameLength(emptyArrayLong, nullArrayShort));
assertTrue(ArrayUtils.isSameLength(emptyArrayLong, nullArrayChar));
assertTrue(ArrayUtils.isSameLength(emptyArrayLong, nullArrayByte));
assertTrue(ArrayUtils.isSameLength(emptyArrayLong, nullArrayDouble));
assertTrue(ArrayUtils.isSameLength(emptyArrayLong, nullArrayFloat));
assertTrue(ArrayUtils.isSameLength(emptyArrayInt, nullArrayObject));
assertTrue(ArrayUtils.isSameLength(emptyArrayInt, nullArrayBoolean));
assertTrue(ArrayUtils.isSameLength(emptyArrayInt, nullArrayLong));
assertTrue(ArrayUtils.isSameLength(emptyArrayInt, nullArrayInt));
assertTrue(ArrayUtils.isSameLength(emptyArrayInt, nullArrayShort));
assertTrue(ArrayUtils.isSameLength(emptyArrayInt, nullArrayChar));
assertTrue(ArrayUtils.isSameLength(emptyArrayInt, nullArrayByte));
assertTrue(ArrayUtils.isSameLength(emptyArrayInt, nullArrayDouble));
assertTrue(ArrayUtils.isSameLength(emptyArrayInt, nullArrayFloat));
assertTrue(ArrayUtils.isSameLength(emptyArrayShort, nullArrayObject));
assertTrue(ArrayUtils.isSameLength(emptyArrayShort, nullArrayBoolean));
assertTrue(ArrayUtils.isSameLength(emptyArrayShort, nullArrayLong));
assertTrue(ArrayUtils.isSameLength(emptyArrayShort, nullArrayInt));
assertTrue(ArrayUtils.isSameLength(emptyArrayShort, nullArrayShort));
assertTrue(ArrayUtils.isSameLength(emptyArrayShort, nullArrayChar));
assertTrue(ArrayUtils.isSameLength(emptyArrayShort, nullArrayByte));
assertTrue(ArrayUtils.isSameLength(emptyArrayShort, nullArrayDouble));
assertTrue(ArrayUtils.isSameLength(emptyArrayShort, nullArrayFloat));
assertTrue(ArrayUtils.isSameLength(emptyArrayChar, nullArrayObject));
assertTrue(ArrayUtils.isSameLength(emptyArrayChar, nullArrayBoolean));
assertTrue(ArrayUtils.isSameLength(emptyArrayChar, nullArrayLong));
assertTrue(ArrayUtils.isSameLength(emptyArrayChar, nullArrayInt));
assertTrue(ArrayUtils.isSameLength(emptyArrayChar, nullArrayShort));
assertTrue(ArrayUtils.isSameLength(emptyArrayChar, nullArrayChar));
assertTrue(ArrayUtils.isSameLength(emptyArrayChar, nullArrayByte));
assertTrue(ArrayUtils.isSameLength(emptyArrayChar, nullArrayDouble));
assertTrue(ArrayUtils.isSameLength(emptyArrayChar, nullArrayFloat));
assertTrue(ArrayUtils.isSameLength(emptyArrayByte, nullArrayObject));
assertTrue(ArrayUtils.isSameLength(emptyArrayByte, nullArrayBoolean));
assertTrue(ArrayUtils.isSameLength(emptyArrayByte, nullArrayLong));
assertTrue(ArrayUtils.isSameLength(emptyArrayByte, nullArrayInt));
assertTrue(ArrayUtils.isSameLength(emptyArrayByte, nullArrayShort));
assertTrue(ArrayUtils.isSameLength(emptyArrayByte, nullArrayChar));
assertTrue(ArrayUtils.isSameLength(emptyArrayByte, nullArrayByte));
assertTrue(ArrayUtils.isSameLength(emptyArrayByte, nullArrayDouble));
assertTrue(ArrayUtils.isSameLength(emptyArrayByte, nullArrayFloat));
assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, nullArrayObject));
assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, nullArrayBoolean));
assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, nullArrayLong));
assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, nullArrayInt));
assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, nullArrayShort));
assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, nullArrayChar));
assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, nullArrayByte));
assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, nullArrayDouble));
assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, nullArrayFloat));
assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, nullArrayObject));
assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, nullArrayBoolean));
assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, nullArrayLong));
assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, nullArrayInt));
assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, nullArrayShort));
assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, nullArrayChar));
assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, nullArrayByte));
assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, nullArrayDouble));
assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, nullArrayFloat));
assertTrue(ArrayUtils.isSameLength(emptyArrayObject, emptyArrayObject));
assertTrue(ArrayUtils.isSameLength(emptyArrayObject, emptyArrayBoolean));
assertTrue(ArrayUtils.isSameLength(emptyArrayObject, emptyArrayLong));
assertTrue(ArrayUtils.isSameLength(emptyArrayObject, emptyArrayInt));
assertTrue(ArrayUtils.isSameLength(emptyArrayObject, emptyArrayShort));
assertTrue(ArrayUtils.isSameLength(emptyArrayObject, emptyArrayChar));
assertTrue(ArrayUtils.isSameLength(emptyArrayObject, emptyArrayByte));
assertTrue(ArrayUtils.isSameLength(emptyArrayObject, emptyArrayDouble));
assertTrue(ArrayUtils.isSameLength(emptyArrayObject, emptyArrayFloat));
assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, emptyArrayObject));
assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, emptyArrayBoolean));
assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, emptyArrayLong));
assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, emptyArrayInt));
assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, emptyArrayShort));
assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, emptyArrayChar));
assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, emptyArrayByte));
assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, emptyArrayDouble));
assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, emptyArrayFloat));
assertTrue(ArrayUtils.isSameLength(emptyArrayLong, emptyArrayObject));
assertTrue(ArrayUtils.isSameLength(emptyArrayLong, emptyArrayBoolean));
assertTrue(ArrayUtils.isSameLength(emptyArrayLong, emptyArrayLong));
assertTrue(ArrayUtils.isSameLength(emptyArrayLong, emptyArrayInt));
assertTrue(ArrayUtils.isSameLength(emptyArrayLong, emptyArrayShort));
assertTrue(ArrayUtils.isSameLength(emptyArrayLong, emptyArrayChar));
assertTrue(ArrayUtils.isSameLength(emptyArrayLong, emptyArrayByte));
assertTrue(ArrayUtils.isSameLength(emptyArrayLong, emptyArrayDouble));
assertTrue(ArrayUtils.isSameLength(emptyArrayLong, emptyArrayFloat));
assertTrue(ArrayUtils.isSameLength(emptyArrayInt, emptyArrayObject));
assertTrue(ArrayUtils.isSameLength(emptyArrayInt, emptyArrayBoolean));
assertTrue(ArrayUtils.isSameLength(emptyArrayInt, emptyArrayLong));
assertTrue(ArrayUtils.isSameLength(emptyArrayInt, emptyArrayInt));
assertTrue(ArrayUtils.isSameLength(emptyArrayInt, emptyArrayShort));
assertTrue(ArrayUtils.isSameLength(emptyArrayInt, emptyArrayChar));
assertTrue(ArrayUtils.isSameLength(emptyArrayInt, emptyArrayByte));
assertTrue(ArrayUtils.isSameLength(emptyArrayInt, emptyArrayDouble));
assertTrue(ArrayUtils.isSameLength(emptyArrayInt, emptyArrayFloat));
assertTrue(ArrayUtils.isSameLength(emptyArrayShort, emptyArrayObject));
assertTrue(ArrayUtils.isSameLength(emptyArrayShort, emptyArrayBoolean));
assertTrue(ArrayUtils.isSameLength(emptyArrayShort, emptyArrayLong));
assertTrue(ArrayUtils.isSameLength(emptyArrayShort, emptyArrayInt));
assertTrue(ArrayUtils.isSameLength(emptyArrayShort, emptyArrayShort));
assertTrue(ArrayUtils.isSameLength(emptyArrayShort, emptyArrayChar));
assertTrue(ArrayUtils.isSameLength(emptyArrayShort, emptyArrayByte));
assertTrue(ArrayUtils.isSameLength(emptyArrayShort, emptyArrayDouble));
assertTrue(ArrayUtils.isSameLength(emptyArrayShort, emptyArrayFloat));
assertTrue(ArrayUtils.isSameLength(emptyArrayChar, emptyArrayObject));
assertTrue(ArrayUtils.isSameLength(emptyArrayChar, emptyArrayBoolean));
assertTrue(ArrayUtils.isSameLength(emptyArrayChar, emptyArrayLong));
assertTrue(ArrayUtils.isSameLength(emptyArrayChar, emptyArrayInt));
assertTrue(ArrayUtils.isSameLength(emptyArrayChar, emptyArrayShort));
assertTrue(ArrayUtils.isSameLength(emptyArrayChar, emptyArrayChar));
assertTrue(ArrayUtils.isSameLength(emptyArrayChar, emptyArrayByte));
assertTrue(ArrayUtils.isSameLength(emptyArrayChar, emptyArrayDouble));
assertTrue(ArrayUtils.isSameLength(emptyArrayChar, emptyArrayFloat));
assertTrue(ArrayUtils.isSameLength(emptyArrayByte, emptyArrayObject));
assertTrue(ArrayUtils.isSameLength(emptyArrayByte, emptyArrayBoolean));
assertTrue(ArrayUtils.isSameLength(emptyArrayByte, emptyArrayLong));
assertTrue(ArrayUtils.isSameLength(emptyArrayByte, emptyArrayInt));
assertTrue(ArrayUtils.isSameLength(emptyArrayByte, emptyArrayShort));
assertTrue(ArrayUtils.isSameLength(emptyArrayByte, emptyArrayChar));
assertTrue(ArrayUtils.isSameLength(emptyArrayByte, emptyArrayByte));
assertTrue(ArrayUtils.isSameLength(emptyArrayByte, emptyArrayDouble));
assertTrue(ArrayUtils.isSameLength(emptyArrayByte, emptyArrayFloat));
assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, emptyArrayObject));
assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, emptyArrayBoolean));
assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, emptyArrayLong));
assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, emptyArrayInt));
assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, emptyArrayShort));
assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, emptyArrayChar));
assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, emptyArrayByte));
assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, emptyArrayDouble));
assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, emptyArrayFloat));
assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, emptyArrayObject));
assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, emptyArrayBoolean));
assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, emptyArrayLong));
assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, emptyArrayInt));
assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, emptyArrayShort));
assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, emptyArrayChar));
assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, emptyArrayByte));
assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, emptyArrayDouble));
assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, emptyArrayFloat));
assertFalse(ArrayUtils.isSameLength(emptyArrayObject, oneArrayObject));
assertFalse(ArrayUtils.isSameLength(emptyArrayObject, oneArrayBoolean));
assertFalse(ArrayUtils.isSameLength(emptyArrayObject, oneArrayLong));
assertFalse(ArrayUtils.isSameLength(emptyArrayObject, oneArrayInt));
assertFalse(ArrayUtils.isSameLength(emptyArrayObject, oneArrayShort));
assertFalse(ArrayUtils.isSameLength(emptyArrayObject, oneArrayChar));
assertFalse(ArrayUtils.isSameLength(emptyArrayObject, oneArrayByte));
assertFalse(ArrayUtils.isSameLength(emptyArrayObject, oneArrayDouble));
assertFalse(ArrayUtils.isSameLength(emptyArrayObject, oneArrayFloat));
assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, oneArrayObject));
assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, oneArrayBoolean));
assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, oneArrayLong));
assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, oneArrayInt));
assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, oneArrayShort));
assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, oneArrayChar));
assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, oneArrayByte));
assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, oneArrayDouble));
assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, oneArrayFloat));
assertFalse(ArrayUtils.isSameLength(emptyArrayLong, oneArrayObject));
assertFalse(ArrayUtils.isSameLength(emptyArrayLong, oneArrayBoolean));
assertFalse(ArrayUtils.isSameLength(emptyArrayLong, oneArrayLong));
assertFalse(ArrayUtils.isSameLength(emptyArrayLong, oneArrayInt));
assertFalse(ArrayUtils.isSameLength(emptyArrayLong, oneArrayShort));
assertFalse(ArrayUtils.isSameLength(emptyArrayLong, oneArrayChar));
assertFalse(ArrayUtils.isSameLength(emptyArrayLong, oneArrayByte));
assertFalse(ArrayUtils.isSameLength(emptyArrayLong, oneArrayDouble));
assertFalse(ArrayUtils.isSameLength(emptyArrayLong, oneArrayFloat));
assertFalse(ArrayUtils.isSameLength(emptyArrayInt, oneArrayObject));
assertFalse(ArrayUtils.isSameLength(emptyArrayInt, oneArrayBoolean));
assertFalse(ArrayUtils.isSameLength(emptyArrayInt, oneArrayLong));
assertFalse(ArrayUtils.isSameLength(emptyArrayInt, oneArrayInt));
assertFalse(ArrayUtils.isSameLength(emptyArrayInt, oneArrayShort));
assertFalse(ArrayUtils.isSameLength(emptyArrayInt, oneArrayChar));
assertFalse(ArrayUtils.isSameLength(emptyArrayInt, oneArrayByte));
assertFalse(ArrayUtils.isSameLength(emptyArrayInt, oneArrayDouble));
assertFalse(ArrayUtils.isSameLength(emptyArrayInt, oneArrayFloat));
assertFalse(ArrayUtils.isSameLength(emptyArrayShort, oneArrayObject));
assertFalse(ArrayUtils.isSameLength(emptyArrayShort, oneArrayBoolean));
assertFalse(ArrayUtils.isSameLength(emptyArrayShort, oneArrayLong));
assertFalse(ArrayUtils.isSameLength(emptyArrayShort, oneArrayInt));
assertFalse(ArrayUtils.isSameLength(emptyArrayShort, oneArrayShort));
assertFalse(ArrayUtils.isSameLength(emptyArrayShort, oneArrayChar));
assertFalse(ArrayUtils.isSameLength(emptyArrayShort, oneArrayByte));
assertFalse(ArrayUtils.isSameLength(emptyArrayShort, oneArrayDouble));
assertFalse(ArrayUtils.isSameLength(emptyArrayShort, oneArrayFloat));
assertFalse(ArrayUtils.isSameLength(emptyArrayChar, oneArrayObject));
assertFalse(ArrayUtils.isSameLength(emptyArrayChar, oneArrayBoolean));
assertFalse(ArrayUtils.isSameLength(emptyArrayChar, oneArrayLong));
assertFalse(ArrayUtils.isSameLength(emptyArrayChar, oneArrayInt));
assertFalse(ArrayUtils.isSameLength(emptyArrayChar, oneArrayShort));
assertFalse(ArrayUtils.isSameLength(emptyArrayChar, oneArrayChar));
assertFalse(ArrayUtils.isSameLength(emptyArrayChar, oneArrayByte));
assertFalse(ArrayUtils.isSameLength(emptyArrayChar, oneArrayDouble));
assertFalse(ArrayUtils.isSameLength(emptyArrayChar, oneArrayFloat));
assertFalse(ArrayUtils.isSameLength(emptyArrayByte, oneArrayObject));
assertFalse(ArrayUtils.isSameLength(emptyArrayByte, oneArrayBoolean));
assertFalse(ArrayUtils.isSameLength(emptyArrayByte, oneArrayLong));
assertFalse(ArrayUtils.isSameLength(emptyArrayByte, oneArrayInt));
assertFalse(ArrayUtils.isSameLength(emptyArrayByte, oneArrayShort));
assertFalse(ArrayUtils.isSameLength(emptyArrayByte, oneArrayChar));
assertFalse(ArrayUtils.isSameLength(emptyArrayByte, oneArrayByte));
assertFalse(ArrayUtils.isSameLength(emptyArrayByte, oneArrayDouble));
assertFalse(ArrayUtils.isSameLength(emptyArrayByte, oneArrayFloat));
assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, oneArrayObject));
assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, oneArrayBoolean));
assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, oneArrayLong));
assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, oneArrayInt));
assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, oneArrayShort));
assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, oneArrayChar));
assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, oneArrayByte));
assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, oneArrayDouble));
assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, oneArrayFloat));
assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, oneArrayObject));
assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, oneArrayBoolean));
assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, oneArrayLong));
assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, oneArrayInt));
assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, oneArrayShort));
assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, oneArrayChar));
assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, oneArrayByte));
assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, oneArrayDouble));
assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, oneArrayFloat));
assertFalse(ArrayUtils.isSameLength(emptyArrayObject, twoArrayObject));
assertFalse(ArrayUtils.isSameLength(emptyArrayObject, twoArrayBoolean));
assertFalse(ArrayUtils.isSameLength(emptyArrayObject, twoArrayLong));
assertFalse(ArrayUtils.isSameLength(emptyArrayObject, twoArrayInt));
assertFalse(ArrayUtils.isSameLength(emptyArrayObject, twoArrayShort));
assertFalse(ArrayUtils.isSameLength(emptyArrayObject, twoArrayChar));
assertFalse(ArrayUtils.isSameLength(emptyArrayObject, twoArrayByte));
assertFalse(ArrayUtils.isSameLength(emptyArrayObject, twoArrayDouble));
assertFalse(ArrayUtils.isSameLength(emptyArrayObject, twoArrayFloat));
assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, twoArrayObject));
assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, twoArrayBoolean));
assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, twoArrayLong));
assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, twoArrayInt));
assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, twoArrayShort));
assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, twoArrayChar));
assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, twoArrayByte));
assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, twoArrayDouble));
assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, twoArrayFloat));
assertFalse(ArrayUtils.isSameLength(emptyArrayLong, twoArrayObject));
assertFalse(ArrayUtils.isSameLength(emptyArrayLong, twoArrayBoolean));
assertFalse(ArrayUtils.isSameLength(emptyArrayLong, twoArrayLong));
assertFalse(ArrayUtils.isSameLength(emptyArrayLong, twoArrayInt));
assertFalse(ArrayUtils.isSameLength(emptyArrayLong, twoArrayShort));
assertFalse(ArrayUtils.isSameLength(emptyArrayLong, twoArrayChar));
assertFalse(ArrayUtils.isSameLength(emptyArrayLong, twoArrayByte));
assertFalse(ArrayUtils.isSameLength(emptyArrayLong, twoArrayDouble));
assertFalse(ArrayUtils.isSameLength(emptyArrayLong, twoArrayFloat));
assertFalse(ArrayUtils.isSameLength(emptyArrayInt, twoArrayObject));
assertFalse(ArrayUtils.isSameLength(emptyArrayInt, twoArrayBoolean));
assertFalse(ArrayUtils.isSameLength(emptyArrayInt, twoArrayLong));
assertFalse(ArrayUtils.isSameLength(emptyArrayInt, twoArrayInt));
assertFalse(ArrayUtils.isSameLength(emptyArrayInt, twoArrayShort));
assertFalse(ArrayUtils.isSameLength(emptyArrayInt, twoArrayChar));
assertFalse(ArrayUtils.isSameLength(emptyArrayInt, twoArrayByte));
assertFalse(ArrayUtils.isSameLength(emptyArrayInt, twoArrayDouble));
assertFalse(ArrayUtils.isSameLength(emptyArrayInt, twoArrayFloat));
assertFalse(ArrayUtils.isSameLength(emptyArrayShort, twoArrayObject));
assertFalse(ArrayUtils.isSameLength(emptyArrayShort, twoArrayBoolean));
assertFalse(ArrayUtils.isSameLength(emptyArrayShort, twoArrayLong));
assertFalse(ArrayUtils.isSameLength(emptyArrayShort, twoArrayInt));
assertFalse(ArrayUtils.isSameLength(emptyArrayShort, twoArrayShort));
assertFalse(ArrayUtils.isSameLength(emptyArrayShort, twoArrayChar));
assertFalse(ArrayUtils.isSameLength(emptyArrayShort, twoArrayByte));
assertFalse(ArrayUtils.isSameLength(emptyArrayShort, twoArrayDouble));
assertFalse(ArrayUtils.isSameLength(emptyArrayShort, twoArrayFloat));
assertFalse(ArrayUtils.isSameLength(emptyArrayChar, twoArrayObject));
assertFalse(ArrayUtils.isSameLength(emptyArrayChar, twoArrayBoolean));
assertFalse(ArrayUtils.isSameLength(emptyArrayChar, twoArrayLong));
assertFalse(ArrayUtils.isSameLength(emptyArrayChar, twoArrayInt));
assertFalse(ArrayUtils.isSameLength(emptyArrayChar, twoArrayShort));
assertFalse(ArrayUtils.isSameLength(emptyArrayChar, twoArrayChar));
assertFalse(ArrayUtils.isSameLength(emptyArrayChar, twoArrayByte));
assertFalse(ArrayUtils.isSameLength(emptyArrayChar, twoArrayDouble));
assertFalse(ArrayUtils.isSameLength(emptyArrayChar, twoArrayFloat));
assertFalse(ArrayUtils.isSameLength(emptyArrayByte, twoArrayObject));
assertFalse(ArrayUtils.isSameLength(emptyArrayByte, twoArrayBoolean));
assertFalse(ArrayUtils.isSameLength(emptyArrayByte, twoArrayLong));
assertFalse(ArrayUtils.isSameLength(emptyArrayByte, twoArrayInt));
assertFalse(ArrayUtils.isSameLength(emptyArrayByte, twoArrayShort));
assertFalse(ArrayUtils.isSameLength(emptyArrayByte, twoArrayChar));
assertFalse(ArrayUtils.isSameLength(emptyArrayByte, twoArrayByte));
assertFalse(ArrayUtils.isSameLength(emptyArrayByte, twoArrayDouble));
assertFalse(ArrayUtils.isSameLength(emptyArrayByte, twoArrayFloat));
assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, twoArrayObject));
assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, twoArrayBoolean));
assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, twoArrayLong));
assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, twoArrayInt));
assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, twoArrayShort));
assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, twoArrayChar));
assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, twoArrayByte));
assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, twoArrayDouble));
assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, twoArrayFloat));
assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, twoArrayObject));
assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, twoArrayBoolean));
assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, twoArrayLong));
assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, twoArrayInt));
assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, twoArrayShort));
assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, twoArrayChar));
assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, twoArrayByte));
assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, twoArrayDouble));
assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, twoArrayFloat));
assertFalse(ArrayUtils.isSameLength(oneArrayObject, nullArrayObject));
assertFalse(ArrayUtils.isSameLength(oneArrayObject, nullArrayBoolean));
assertFalse(ArrayUtils.isSameLength(oneArrayObject, nullArrayLong));
assertFalse(ArrayUtils.isSameLength(oneArrayObject, nullArrayInt));
assertFalse(ArrayUtils.isSameLength(oneArrayObject, nullArrayShort));
assertFalse(ArrayUtils.isSameLength(oneArrayObject, nullArrayChar));
assertFalse(ArrayUtils.isSameLength(oneArrayObject, nullArrayByte));
assertFalse(ArrayUtils.isSameLength(oneArrayObject, nullArrayDouble));
assertFalse(ArrayUtils.isSameLength(oneArrayObject, nullArrayFloat));
assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, nullArrayObject));
assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, nullArrayBoolean));
assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, nullArrayLong));
assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, nullArrayInt));
assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, nullArrayShort));
assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, nullArrayChar));
assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, nullArrayByte));
assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, nullArrayDouble));
assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, nullArrayFloat));
assertFalse(ArrayUtils.isSameLength(oneArrayLong, nullArrayObject));
assertFalse(ArrayUtils.isSameLength(oneArrayLong, nullArrayBoolean));
assertFalse(ArrayUtils.isSameLength(oneArrayLong, nullArrayLong));
assertFalse(ArrayUtils.isSameLength(oneArrayLong, nullArrayInt));
assertFalse(ArrayUtils.isSameLength(oneArrayLong, nullArrayShort));
assertFalse(ArrayUtils.isSameLength(oneArrayLong, nullArrayChar));
assertFalse(ArrayUtils.isSameLength(oneArrayLong, nullArrayByte));
assertFalse(ArrayUtils.isSameLength(oneArrayLong, nullArrayDouble));
assertFalse(ArrayUtils.isSameLength(oneArrayLong, nullArrayFloat));
assertFalse(ArrayUtils.isSameLength(oneArrayInt, nullArrayObject));
assertFalse(ArrayUtils.isSameLength(oneArrayInt, nullArrayBoolean));
assertFalse(ArrayUtils.isSameLength(oneArrayInt, nullArrayLong));
assertFalse(ArrayUtils.isSameLength(oneArrayInt, nullArrayInt));
assertFalse(ArrayUtils.isSameLength(oneArrayInt, nullArrayShort));
assertFalse(ArrayUtils.isSameLength(oneArrayInt, nullArrayChar));
assertFalse(ArrayUtils.isSameLength(oneArrayInt, nullArrayByte));
assertFalse(ArrayUtils.isSameLength(oneArrayInt, nullArrayDouble));
assertFalse(ArrayUtils.isSameLength(oneArrayInt, nullArrayFloat));
assertFalse(ArrayUtils.isSameLength(oneArrayShort, nullArrayObject));
assertFalse(ArrayUtils.isSameLength(oneArrayShort, nullArrayBoolean));
assertFalse(ArrayUtils.isSameLength(oneArrayShort, nullArrayLong));
assertFalse(ArrayUtils.isSameLength(oneArrayShort, nullArrayInt));
assertFalse(ArrayUtils.isSameLength(oneArrayShort, nullArrayShort));
assertFalse(ArrayUtils.isSameLength(oneArrayShort, nullArrayChar));
assertFalse(ArrayUtils.isSameLength(oneArrayShort, nullArrayByte));
assertFalse(ArrayUtils.isSameLength(oneArrayShort, nullArrayDouble));
assertFalse(ArrayUtils.isSameLength(oneArrayShort, nullArrayFloat));
assertFalse(ArrayUtils.isSameLength(oneArrayChar, nullArrayObject));
assertFalse(ArrayUtils.isSameLength(oneArrayChar, nullArrayBoolean));
assertFalse(ArrayUtils.isSameLength(oneArrayChar, nullArrayLong));
assertFalse(ArrayUtils.isSameLength(oneArrayChar, nullArrayInt));
assertFalse(ArrayUtils.isSameLength(oneArrayChar, nullArrayShort));
assertFalse(ArrayUtils.isSameLength(oneArrayChar, nullArrayChar));
assertFalse(ArrayUtils.isSameLength(oneArrayChar, nullArrayByte));
assertFalse(ArrayUtils.isSameLength(oneArrayChar, nullArrayDouble));
assertFalse(ArrayUtils.isSameLength(oneArrayChar, nullArrayFloat));
assertFalse(ArrayUtils.isSameLength(oneArrayByte, nullArrayObject));
assertFalse(ArrayUtils.isSameLength(oneArrayByte, nullArrayBoolean));
assertFalse(ArrayUtils.isSameLength(oneArrayByte, nullArrayLong));
assertFalse(ArrayUtils.isSameLength(oneArrayByte, nullArrayInt));
assertFalse(ArrayUtils.isSameLength(oneArrayByte, nullArrayShort));
assertFalse(ArrayUtils.isSameLength(oneArrayByte, nullArrayChar));
assertFalse(ArrayUtils.isSameLength(oneArrayByte, nullArrayByte));
assertFalse(ArrayUtils.isSameLength(oneArrayByte, nullArrayDouble));
assertFalse(ArrayUtils.isSameLength(oneArrayByte, nullArrayFloat));
assertFalse(ArrayUtils.isSameLength(oneArrayDouble, nullArrayObject));
assertFalse(ArrayUtils.isSameLength(oneArrayDouble, nullArrayBoolean));
assertFalse(ArrayUtils.isSameLength(oneArrayDouble, nullArrayLong));
assertFalse(ArrayUtils.isSameLength(oneArrayDouble, nullArrayInt));
assertFalse(ArrayUtils.isSameLength(oneArrayDouble, nullArrayShort));
assertFalse(ArrayUtils.isSameLength(oneArrayDouble, nullArrayChar));
assertFalse(ArrayUtils.isSameLength(oneArrayDouble, nullArrayByte));
assertFalse(ArrayUtils.isSameLength(oneArrayDouble, nullArrayDouble));
assertFalse(ArrayUtils.isSameLength(oneArrayDouble, nullArrayFloat));
assertFalse(ArrayUtils.isSameLength(oneArrayFloat, nullArrayObject));
assertFalse(ArrayUtils.isSameLength(oneArrayFloat, nullArrayBoolean));
assertFalse(ArrayUtils.isSameLength(oneArrayFloat, nullArrayLong));
assertFalse(ArrayUtils.isSameLength(oneArrayFloat, nullArrayInt));
assertFalse(ArrayUtils.isSameLength(oneArrayFloat, nullArrayShort));
assertFalse(ArrayUtils.isSameLength(oneArrayFloat, nullArrayChar));
assertFalse(ArrayUtils.isSameLength(oneArrayFloat, nullArrayByte));
assertFalse(ArrayUtils.isSameLength(oneArrayFloat, nullArrayDouble));
assertFalse(ArrayUtils.isSameLength(oneArrayFloat, nullArrayFloat));
assertFalse(ArrayUtils.isSameLength(oneArrayObject, emptyArrayObject));
assertFalse(ArrayUtils.isSameLength(oneArrayObject, emptyArrayBoolean));
assertFalse(ArrayUtils.isSameLength(oneArrayObject, emptyArrayLong));
assertFalse(ArrayUtils.isSameLength(oneArrayObject, emptyArrayInt));
assertFalse(ArrayUtils.isSameLength(oneArrayObject, emptyArrayShort));
assertFalse(ArrayUtils.isSameLength(oneArrayObject, emptyArrayChar));
assertFalse(ArrayUtils.isSameLength(oneArrayObject, emptyArrayByte));
assertFalse(ArrayUtils.isSameLength(oneArrayObject, emptyArrayDouble));
assertFalse(ArrayUtils.isSameLength(oneArrayObject, emptyArrayFloat));
assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, emptyArrayObject));
assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, emptyArrayBoolean));
assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, emptyArrayLong));
assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, emptyArrayInt));
assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, emptyArrayShort));
assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, emptyArrayChar));
assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, emptyArrayByte));
assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, emptyArrayDouble));
assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, emptyArrayFloat));
assertFalse(ArrayUtils.isSameLength(oneArrayLong, emptyArrayObject));
assertFalse(ArrayUtils.isSameLength(oneArrayLong, emptyArrayBoolean));
assertFalse(ArrayUtils.isSameLength(oneArrayLong, emptyArrayLong));
assertFalse(ArrayUtils.isSameLength(oneArrayLong, emptyArrayInt));
assertFalse(ArrayUtils.isSameLength(oneArrayLong, emptyArrayShort));
assertFalse(ArrayUtils.isSameLength(oneArrayLong, emptyArrayChar));
assertFalse(ArrayUtils.isSameLength(oneArrayLong, emptyArrayByte));
assertFalse(ArrayUtils.isSameLength(oneArrayLong, emptyArrayDouble));
assertFalse(ArrayUtils.isSameLength(oneArrayLong, emptyArrayFloat));
assertFalse(ArrayUtils.isSameLength(oneArrayInt, emptyArrayObject));
assertFalse(ArrayUtils.isSameLength(oneArrayInt, emptyArrayBoolean));
assertFalse(ArrayUtils.isSameLength(oneArrayInt, emptyArrayLong));
assertFalse(ArrayUtils.isSameLength(oneArrayInt, emptyArrayInt));
assertFalse(ArrayUtils.isSameLength(oneArrayInt, emptyArrayShort));
assertFalse(ArrayUtils.isSameLength(oneArrayInt, emptyArrayChar));
assertFalse(ArrayUtils.isSameLength(oneArrayInt, emptyArrayByte));
assertFalse(ArrayUtils.isSameLength(oneArrayInt, emptyArrayDouble));
assertFalse(ArrayUtils.isSameLength(oneArrayInt, emptyArrayFloat));
assertFalse(ArrayUtils.isSameLength(oneArrayShort, emptyArrayObject));
assertFalse(ArrayUtils.isSameLength(oneArrayShort, emptyArrayBoolean));
assertFalse(ArrayUtils.isSameLength(oneArrayShort, emptyArrayLong));
assertFalse(ArrayUtils.isSameLength(oneArrayShort, emptyArrayInt));
assertFalse(ArrayUtils.isSameLength(oneArrayShort, emptyArrayShort));
assertFalse(ArrayUtils.isSameLength(oneArrayShort, emptyArrayChar));
assertFalse(ArrayUtils.isSameLength(oneArrayShort, emptyArrayByte));
assertFalse(ArrayUtils.isSameLength(oneArrayShort, emptyArrayDouble));
assertFalse(ArrayUtils.isSameLength(oneArrayShort, emptyArrayFloat));
assertFalse(ArrayUtils.isSameLength(oneArrayChar, emptyArrayObject));
assertFalse(ArrayUtils.isSameLength(oneArrayChar, emptyArrayBoolean));
assertFalse(ArrayUtils.isSameLength(oneArrayChar, emptyArrayLong));
assertFalse(ArrayUtils.isSameLength(oneArrayChar, emptyArrayInt));
assertFalse(ArrayUtils.isSameLength(oneArrayChar, emptyArrayShort));
assertFalse(ArrayUtils.isSameLength(oneArrayChar, emptyArrayChar));
assertFalse(ArrayUtils.isSameLength(oneArrayChar, emptyArrayByte));
assertFalse(ArrayUtils.isSameLength(oneArrayChar, emptyArrayDouble));
assertFalse(ArrayUtils.isSameLength(oneArrayChar, emptyArrayFloat));
assertFalse(ArrayUtils.isSameLength(oneArrayByte, emptyArrayObject));
assertFalse(ArrayUtils.isSameLength(oneArrayByte, emptyArrayBoolean));
assertFalse(ArrayUtils.isSameLength(oneArrayByte, emptyArrayLong));
assertFalse(ArrayUtils.isSameLength(oneArrayByte, emptyArrayInt));
assertFalse(ArrayUtils.isSameLength(oneArrayByte, emptyArrayShort));
assertFalse(ArrayUtils.isSameLength(oneArrayByte, emptyArrayChar));
assertFalse(ArrayUtils.isSameLength(oneArrayByte, emptyArrayByte));
assertFalse(ArrayUtils.isSameLength(oneArrayByte, emptyArrayDouble));
assertFalse(ArrayUtils.isSameLength(oneArrayByte, emptyArrayFloat));
assertFalse(ArrayUtils.isSameLength(oneArrayDouble, emptyArrayObject));
assertFalse(ArrayUtils.isSameLength(oneArrayDouble, emptyArrayBoolean));
assertFalse(ArrayUtils.isSameLength(oneArrayDouble, emptyArrayLong));
assertFalse(ArrayUtils.isSameLength(oneArrayDouble, emptyArrayInt));
assertFalse(ArrayUtils.isSameLength(oneArrayDouble, emptyArrayShort));
assertFalse(ArrayUtils.isSameLength(oneArrayDouble, emptyArrayChar));
assertFalse(ArrayUtils.isSameLength(oneArrayDouble, emptyArrayByte));
assertFalse(ArrayUtils.isSameLength(oneArrayDouble, emptyArrayDouble));
assertFalse(ArrayUtils.isSameLength(oneArrayDouble, emptyArrayFloat));
assertFalse(ArrayUtils.isSameLength(oneArrayFloat, emptyArrayObject));
assertFalse(ArrayUtils.isSameLength(oneArrayFloat, emptyArrayBoolean));
assertFalse(ArrayUtils.isSameLength(oneArrayFloat, emptyArrayLong));
assertFalse(ArrayUtils.isSameLength(oneArrayFloat, emptyArrayInt));
assertFalse(ArrayUtils.isSameLength(oneArrayFloat, emptyArrayShort));
assertFalse(ArrayUtils.isSameLength(oneArrayFloat, emptyArrayChar));
assertFalse(ArrayUtils.isSameLength(oneArrayFloat, emptyArrayByte));
assertFalse(ArrayUtils.isSameLength(oneArrayFloat, emptyArrayDouble));
assertFalse(ArrayUtils.isSameLength(oneArrayFloat, emptyArrayFloat));
assertTrue(ArrayUtils.isSameLength(oneArrayObject, oneArrayObject));
assertTrue(ArrayUtils.isSameLength(oneArrayObject, oneArrayBoolean));
assertTrue(ArrayUtils.isSameLength(oneArrayObject, oneArrayLong));
assertTrue(ArrayUtils.isSameLength(oneArrayObject, oneArrayInt));
assertTrue(ArrayUtils.isSameLength(oneArrayObject, oneArrayShort));
assertTrue(ArrayUtils.isSameLength(oneArrayObject, oneArrayChar));
assertTrue(ArrayUtils.isSameLength(oneArrayObject, oneArrayByte));
assertTrue(ArrayUtils.isSameLength(oneArrayObject, oneArrayDouble));
assertTrue(ArrayUtils.isSameLength(oneArrayObject, oneArrayFloat));
assertTrue(ArrayUtils.isSameLength(oneArrayBoolean, oneArrayObject));
assertTrue(ArrayUtils.isSameLength(oneArrayBoolean, oneArrayBoolean));
assertTrue(ArrayUtils.isSameLength(oneArrayBoolean, oneArrayLong));
assertTrue(ArrayUtils.isSameLength(oneArrayBoolean, oneArrayInt));
assertTrue(ArrayUtils.isSameLength(oneArrayBoolean, oneArrayShort));
assertTrue(ArrayUtils.isSameLength(oneArrayBoolean, oneArrayChar));
assertTrue(ArrayUtils.isSameLength(oneArrayBoolean, oneArrayByte));
assertTrue(ArrayUtils.isSameLength(oneArrayBoolean, oneArrayDouble));
assertTrue(ArrayUtils.isSameLength(oneArrayBoolean, oneArrayFloat));
assertTrue(ArrayUtils.isSameLength(oneArrayLong, oneArrayObject));
assertTrue(ArrayUtils.isSameLength(oneArrayLong, oneArrayBoolean));
assertTrue(ArrayUtils.isSameLength(oneArrayLong, oneArrayLong));
assertTrue(ArrayUtils.isSameLength(oneArrayLong, oneArrayInt));
assertTrue(ArrayUtils.isSameLength(oneArrayLong, oneArrayShort));
assertTrue(ArrayUtils.isSameLength(oneArrayLong, oneArrayChar));
assertTrue(ArrayUtils.isSameLength(oneArrayLong, oneArrayByte));
assertTrue(ArrayUtils.isSameLength(oneArrayLong, oneArrayDouble));
assertTrue(ArrayUtils.isSameLength(oneArrayLong, oneArrayFloat));
assertTrue(ArrayUtils.isSameLength(oneArrayInt, oneArrayObject));
assertTrue(ArrayUtils.isSameLength(oneArrayInt, oneArrayBoolean));
assertTrue(ArrayUtils.isSameLength(oneArrayInt, oneArrayLong));
assertTrue(ArrayUtils.isSameLength(oneArrayInt, oneArrayInt));
assertTrue(ArrayUtils.isSameLength(oneArrayInt, oneArrayShort));
assertTrue(ArrayUtils.isSameLength(oneArrayInt, oneArrayChar));
assertTrue(ArrayUtils.isSameLength(oneArrayInt, oneArrayByte));
assertTrue(ArrayUtils.isSameLength(oneArrayInt, oneArrayDouble));
assertTrue(ArrayUtils.isSameLength(oneArrayInt, oneArrayFloat));
assertTrue(ArrayUtils.isSameLength(oneArrayShort, oneArrayObject));
assertTrue(ArrayUtils.isSameLength(oneArrayShort, oneArrayBoolean));
assertTrue(ArrayUtils.isSameLength(oneArrayShort, oneArrayLong));
assertTrue(ArrayUtils.isSameLength(oneArrayShort, oneArrayInt));
assertTrue(ArrayUtils.isSameLength(oneArrayShort, oneArrayShort));
assertTrue(ArrayUtils.isSameLength(oneArrayShort, oneArrayChar));
assertTrue(ArrayUtils.isSameLength(oneArrayShort, oneArrayByte));
assertTrue(ArrayUtils.isSameLength(oneArrayShort, oneArrayDouble));
assertTrue(ArrayUtils.isSameLength(oneArrayShort, oneArrayFloat));
assertTrue(ArrayUtils.isSameLength(oneArrayChar, oneArrayObject));
assertTrue(ArrayUtils.isSameLength(oneArrayChar, oneArrayBoolean));
assertTrue(ArrayUtils.isSameLength(oneArrayChar, oneArrayLong));
assertTrue(ArrayUtils.isSameLength(oneArrayChar, oneArrayInt));
assertTrue(ArrayUtils.isSameLength(oneArrayChar, oneArrayShort));
assertTrue(ArrayUtils.isSameLength(oneArrayChar, oneArrayChar));
assertTrue(ArrayUtils.isSameLength(oneArrayChar, oneArrayByte));
assertTrue(ArrayUtils.isSameLength(oneArrayChar, oneArrayDouble));
assertTrue(ArrayUtils.isSameLength(oneArrayChar, oneArrayFloat));
assertTrue(ArrayUtils.isSameLength(oneArrayByte, oneArrayObject));
assertTrue(ArrayUtils.isSameLength(oneArrayByte, oneArrayBoolean));
assertTrue(ArrayUtils.isSameLength(oneArrayByte, oneArrayLong));
assertTrue(ArrayUtils.isSameLength(oneArrayByte, oneArrayInt));
assertTrue(ArrayUtils.isSameLength(oneArrayByte, oneArrayShort));
assertTrue(ArrayUtils.isSameLength(oneArrayByte, oneArrayChar));
assertTrue(ArrayUtils.isSameLength(oneArrayByte, oneArrayByte));
assertTrue(ArrayUtils.isSameLength(oneArrayByte, oneArrayDouble));
assertTrue(ArrayUtils.isSameLength(oneArrayByte, oneArrayFloat));
assertTrue(ArrayUtils.isSameLength(oneArrayDouble, oneArrayObject));
assertTrue(ArrayUtils.isSameLength(oneArrayDouble, oneArrayBoolean));
assertTrue(ArrayUtils.isSameLength(oneArrayDouble, oneArrayLong));
assertTrue(ArrayUtils.isSameLength(oneArrayDouble, oneArrayInt));
assertTrue(ArrayUtils.isSameLength(oneArrayDouble, oneArrayShort));
assertTrue(ArrayUtils.isSameLength(oneArrayDouble, oneArrayChar));
assertTrue(ArrayUtils.isSameLength(oneArrayDouble, oneArrayByte));
assertTrue(ArrayUtils.isSameLength(oneArrayDouble, oneArrayDouble));
assertTrue(ArrayUtils.isSameLength(oneArrayDouble, oneArrayFloat));
assertTrue(ArrayUtils.isSameLength(oneArrayFloat, oneArrayObject));
assertTrue(ArrayUtils.isSameLength(oneArrayFloat, oneArrayBoolean));
assertTrue(ArrayUtils.isSameLength(oneArrayFloat, oneArrayLong));
assertTrue(ArrayUtils.isSameLength(oneArrayFloat, oneArrayInt));
assertTrue(ArrayUtils.isSameLength(oneArrayFloat, oneArrayShort));
assertTrue(ArrayUtils.isSameLength(oneArrayFloat, oneArrayChar));
assertTrue(ArrayUtils.isSameLength(oneArrayFloat, oneArrayByte));
assertTrue(ArrayUtils.isSameLength(oneArrayFloat, oneArrayDouble));
assertTrue(ArrayUtils.isSameLength(oneArrayFloat, oneArrayFloat));
assertFalse(ArrayUtils.isSameLength(oneArrayObject, twoArrayObject));
assertFalse(ArrayUtils.isSameLength(oneArrayObject, twoArrayBoolean));
assertFalse(ArrayUtils.isSameLength(oneArrayObject, twoArrayLong));
assertFalse(ArrayUtils.isSameLength(oneArrayObject, twoArrayInt));
assertFalse(ArrayUtils.isSameLength(oneArrayObject, twoArrayShort));
assertFalse(ArrayUtils.isSameLength(oneArrayObject, twoArrayChar));
assertFalse(ArrayUtils.isSameLength(oneArrayObject, twoArrayByte));
assertFalse(ArrayUtils.isSameLength(oneArrayObject, twoArrayDouble));
assertFalse(ArrayUtils.isSameLength(oneArrayObject, twoArrayFloat));
assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, twoArrayObject));
assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, twoArrayBoolean));
assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, twoArrayLong));
assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, twoArrayInt));
assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, twoArrayShort));
assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, twoArrayChar));
assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, twoArrayByte));
assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, twoArrayDouble));
assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, twoArrayFloat));
assertFalse(ArrayUtils.isSameLength(oneArrayLong, twoArrayObject));
assertFalse(ArrayUtils.isSameLength(oneArrayLong, twoArrayBoolean));
assertFalse(ArrayUtils.isSameLength(oneArrayLong, twoArrayLong));
assertFalse(ArrayUtils.isSameLength(oneArrayLong, twoArrayInt));
assertFalse(ArrayUtils.isSameLength(oneArrayLong, twoArrayShort));
assertFalse(ArrayUtils.isSameLength(oneArrayLong, twoArrayChar));
assertFalse(ArrayUtils.isSameLength(oneArrayLong, twoArrayByte));
assertFalse(ArrayUtils.isSameLength(oneArrayLong, twoArrayDouble));
assertFalse(ArrayUtils.isSameLength(oneArrayLong, twoArrayFloat));
assertFalse(ArrayUtils.isSameLength(oneArrayInt, twoArrayObject));
assertFalse(ArrayUtils.isSameLength(oneArrayInt, twoArrayBoolean));
assertFalse(ArrayUtils.isSameLength(oneArrayInt, twoArrayLong));
assertFalse(ArrayUtils.isSameLength(oneArrayInt, twoArrayInt));
assertFalse(ArrayUtils.isSameLength(oneArrayInt, twoArrayShort));
assertFalse(ArrayUtils.isSameLength(oneArrayInt, twoArrayChar));
assertFalse(ArrayUtils.isSameLength(oneArrayInt, twoArrayByte));
assertFalse(ArrayUtils.isSameLength(oneArrayInt, twoArrayDouble));
assertFalse(ArrayUtils.isSameLength(oneArrayInt, twoArrayFloat));
assertFalse(ArrayUtils.isSameLength(oneArrayShort, twoArrayObject));
assertFalse(ArrayUtils.isSameLength(oneArrayShort, twoArrayBoolean));
assertFalse(ArrayUtils.isSameLength(oneArrayShort, twoArrayLong));
assertFalse(ArrayUtils.isSameLength(oneArrayShort, twoArrayInt));
assertFalse(ArrayUtils.isSameLength(oneArrayShort, twoArrayShort));
assertFalse(ArrayUtils.isSameLength(oneArrayShort, twoArrayChar));
assertFalse(ArrayUtils.isSameLength(oneArrayShort, twoArrayByte));
assertFalse(ArrayUtils.isSameLength(oneArrayShort, twoArrayDouble));
assertFalse(ArrayUtils.isSameLength(oneArrayShort, twoArrayFloat));
assertFalse(ArrayUtils.isSameLength(oneArrayChar, twoArrayObject));
assertFalse(ArrayUtils.isSameLength(oneArrayChar, twoArrayBoolean));
assertFalse(ArrayUtils.isSameLength(oneArrayChar, twoArrayLong));
assertFalse(ArrayUtils.isSameLength(oneArrayChar, twoArrayInt));
assertFalse(ArrayUtils.isSameLength(oneArrayChar, twoArrayShort));
assertFalse(ArrayUtils.isSameLength(oneArrayChar, twoArrayChar));
assertFalse(ArrayUtils.isSameLength(oneArrayChar, twoArrayByte));
assertFalse(ArrayUtils.isSameLength(oneArrayChar, twoArrayDouble));
assertFalse(ArrayUtils.isSameLength(oneArrayChar, twoArrayFloat));
assertFalse(ArrayUtils.isSameLength(oneArrayByte, twoArrayObject));
assertFalse(ArrayUtils.isSameLength(oneArrayByte, twoArrayBoolean));
assertFalse(ArrayUtils.isSameLength(oneArrayByte, twoArrayLong));
assertFalse(ArrayUtils.isSameLength(oneArrayByte, twoArrayInt));
assertFalse(ArrayUtils.isSameLength(oneArrayByte, twoArrayShort));
assertFalse(ArrayUtils.isSameLength(oneArrayByte, twoArrayChar));
assertFalse(ArrayUtils.isSameLength(oneArrayByte, twoArrayByte));
assertFalse(ArrayUtils.isSameLength(oneArrayByte, twoArrayDouble));
assertFalse(ArrayUtils.isSameLength(oneArrayByte, twoArrayFloat));
assertFalse(ArrayUtils.isSameLength(oneArrayDouble, twoArrayObject));
assertFalse(ArrayUtils.isSameLength(oneArrayDouble, twoArrayBoolean));
assertFalse(ArrayUtils.isSameLength(oneArrayDouble, twoArrayLong));
assertFalse(ArrayUtils.isSameLength(oneArrayDouble, twoArrayInt));
assertFalse(ArrayUtils.isSameLength(oneArrayDouble, twoArrayShort));
assertFalse(ArrayUtils.isSameLength(oneArrayDouble, twoArrayChar));
assertFalse(ArrayUtils.isSameLength(oneArrayDouble, twoArrayByte));
assertFalse(ArrayUtils.isSameLength(oneArrayDouble, twoArrayDouble));
assertFalse(ArrayUtils.isSameLength(oneArrayDouble, twoArrayFloat));
assertFalse(ArrayUtils.isSameLength(oneArrayFloat, twoArrayObject));
assertFalse(ArrayUtils.isSameLength(oneArrayFloat, twoArrayBoolean));
assertFalse(ArrayUtils.isSameLength(oneArrayFloat, twoArrayLong));
assertFalse(ArrayUtils.isSameLength(oneArrayFloat, twoArrayInt));
assertFalse(ArrayUtils.isSameLength(oneArrayFloat, twoArrayShort));
assertFalse(ArrayUtils.isSameLength(oneArrayFloat, twoArrayChar));
assertFalse(ArrayUtils.isSameLength(oneArrayFloat, twoArrayByte));
assertFalse(ArrayUtils.isSameLength(oneArrayFloat, twoArrayDouble));
assertFalse(ArrayUtils.isSameLength(oneArrayFloat, twoArrayFloat));
assertFalse(ArrayUtils.isSameLength(twoArrayObject, nullArrayObject));
assertFalse(ArrayUtils.isSameLength(twoArrayObject, nullArrayBoolean));
assertFalse(ArrayUtils.isSameLength(twoArrayObject, nullArrayLong));
assertFalse(ArrayUtils.isSameLength(twoArrayObject, nullArrayInt));
assertFalse(ArrayUtils.isSameLength(twoArrayObject, nullArrayShort));
assertFalse(ArrayUtils.isSameLength(twoArrayObject, nullArrayChar));
assertFalse(ArrayUtils.isSameLength(twoArrayObject, nullArrayByte));
assertFalse(ArrayUtils.isSameLength(twoArrayObject, nullArrayDouble));
assertFalse(ArrayUtils.isSameLength(twoArrayObject, nullArrayFloat));
assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, nullArrayObject));
assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, nullArrayBoolean));
assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, nullArrayLong));
assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, nullArrayInt));
assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, nullArrayShort));
assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, nullArrayChar));
assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, nullArrayByte));
assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, nullArrayDouble));
assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, nullArrayFloat));
assertFalse(ArrayUtils.isSameLength(twoArrayLong, nullArrayObject));
assertFalse(ArrayUtils.isSameLength(twoArrayLong, nullArrayBoolean));
assertFalse(ArrayUtils.isSameLength(twoArrayLong, nullArrayLong));
assertFalse(ArrayUtils.isSameLength(twoArrayLong, nullArrayInt));
assertFalse(ArrayUtils.isSameLength(twoArrayLong, nullArrayShort));
assertFalse(ArrayUtils.isSameLength(twoArrayLong, nullArrayChar));
assertFalse(ArrayUtils.isSameLength(twoArrayLong, nullArrayByte));
assertFalse(ArrayUtils.isSameLength(twoArrayLong, nullArrayDouble));
assertFalse(ArrayUtils.isSameLength(twoArrayLong, nullArrayFloat));
assertFalse(ArrayUtils.isSameLength(twoArrayInt, nullArrayObject));
assertFalse(ArrayUtils.isSameLength(twoArrayInt, nullArrayBoolean));
assertFalse(ArrayUtils.isSameLength(twoArrayInt, nullArrayLong));
assertFalse(ArrayUtils.isSameLength(twoArrayInt, nullArrayInt));
assertFalse(ArrayUtils.isSameLength(twoArrayInt, nullArrayShort));
assertFalse(ArrayUtils.isSameLength(twoArrayInt, nullArrayChar));
assertFalse(ArrayUtils.isSameLength(twoArrayInt, nullArrayByte));
assertFalse(ArrayUtils.isSameLength(twoArrayInt, nullArrayDouble));
assertFalse(ArrayUtils.isSameLength(twoArrayInt, nullArrayFloat));
assertFalse(ArrayUtils.isSameLength(twoArrayShort, nullArrayObject));
assertFalse(ArrayUtils.isSameLength(twoArrayShort, nullArrayBoolean));
assertFalse(ArrayUtils.isSameLength(twoArrayShort, nullArrayLong));
assertFalse(ArrayUtils.isSameLength(twoArrayShort, nullArrayInt));
assertFalse(ArrayUtils.isSameLength(twoArrayShort, nullArrayShort));
assertFalse(ArrayUtils.isSameLength(twoArrayShort, nullArrayChar));
assertFalse(ArrayUtils.isSameLength(twoArrayShort, nullArrayByte));
assertFalse(ArrayUtils.isSameLength(twoArrayShort, nullArrayDouble));
assertFalse(ArrayUtils.isSameLength(twoArrayShort, nullArrayFloat));
assertFalse(ArrayUtils.isSameLength(twoArrayChar, nullArrayObject));
assertFalse(ArrayUtils.isSameLength(twoArrayChar, nullArrayBoolean));
assertFalse(ArrayUtils.isSameLength(twoArrayChar, nullArrayLong));
assertFalse(ArrayUtils.isSameLength(twoArrayChar, nullArrayInt));
assertFalse(ArrayUtils.isSameLength(twoArrayChar, nullArrayShort));
assertFalse(ArrayUtils.isSameLength(twoArrayChar, nullArrayChar));
assertFalse(ArrayUtils.isSameLength(twoArrayChar, nullArrayByte));
assertFalse(ArrayUtils.isSameLength(twoArrayChar, nullArrayDouble));
assertFalse(ArrayUtils.isSameLength(twoArrayChar, nullArrayFloat));
assertFalse(ArrayUtils.isSameLength(twoArrayByte, nullArrayObject));
assertFalse(ArrayUtils.isSameLength(twoArrayByte, nullArrayBoolean));
assertFalse(ArrayUtils.isSameLength(twoArrayByte, nullArrayLong));
assertFalse(ArrayUtils.isSameLength(twoArrayByte, nullArrayInt));
assertFalse(ArrayUtils.isSameLength(twoArrayByte, nullArrayShort));
assertFalse(ArrayUtils.isSameLength(twoArrayByte, nullArrayChar));
assertFalse(ArrayUtils.isSameLength(twoArrayByte, nullArrayByte));
assertFalse(ArrayUtils.isSameLength(twoArrayByte, nullArrayDouble));
assertFalse(ArrayUtils.isSameLength(twoArrayByte, nullArrayFloat));
assertFalse(ArrayUtils.isSameLength(twoArrayDouble, nullArrayObject));
assertFalse(ArrayUtils.isSameLength(twoArrayDouble, nullArrayBoolean));
assertFalse(ArrayUtils.isSameLength(twoArrayDouble, nullArrayLong));
assertFalse(ArrayUtils.isSameLength(twoArrayDouble, nullArrayInt));
assertFalse(ArrayUtils.isSameLength(twoArrayDouble, nullArrayShort));
assertFalse(ArrayUtils.isSameLength(twoArrayDouble, nullArrayChar));
assertFalse(ArrayUtils.isSameLength(twoArrayDouble, nullArrayByte));
assertFalse(ArrayUtils.isSameLength(twoArrayDouble, nullArrayDouble));
assertFalse(ArrayUtils.isSameLength(twoArrayDouble, nullArrayFloat));
assertFalse(ArrayUtils.isSameLength(twoArrayFloat, nullArrayObject));
assertFalse(ArrayUtils.isSameLength(twoArrayFloat, nullArrayBoolean));
assertFalse(ArrayUtils.isSameLength(twoArrayFloat, nullArrayLong));
assertFalse(ArrayUtils.isSameLength(twoArrayFloat, nullArrayInt));
assertFalse(ArrayUtils.isSameLength(twoArrayFloat, nullArrayShort));
assertFalse(ArrayUtils.isSameLength(twoArrayFloat, nullArrayChar));
assertFalse(ArrayUtils.isSameLength(twoArrayFloat, nullArrayByte));
assertFalse(ArrayUtils.isSameLength(twoArrayFloat, nullArrayDouble));
assertFalse(ArrayUtils.isSameLength(twoArrayFloat, nullArrayFloat));
assertFalse(ArrayUtils.isSameLength(twoArrayObject, emptyArrayObject));
assertFalse(ArrayUtils.isSameLength(twoArrayObject, emptyArrayBoolean));
assertFalse(ArrayUtils.isSameLength(twoArrayObject, emptyArrayLong));
assertFalse(ArrayUtils.isSameLength(twoArrayObject, emptyArrayInt));
assertFalse(ArrayUtils.isSameLength(twoArrayObject, emptyArrayShort));
assertFalse(ArrayUtils.isSameLength(twoArrayObject, emptyArrayChar));
assertFalse(ArrayUtils.isSameLength(twoArrayObject, emptyArrayByte));
assertFalse(ArrayUtils.isSameLength(twoArrayObject, emptyArrayDouble));
assertFalse(ArrayUtils.isSameLength(twoArrayObject, emptyArrayFloat));
assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, emptyArrayObject));
assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, emptyArrayBoolean));
assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, emptyArrayLong));
assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, emptyArrayInt));
assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, emptyArrayShort));
assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, emptyArrayChar));
assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, emptyArrayByte));
assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, emptyArrayDouble));
assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, emptyArrayFloat));
assertFalse(ArrayUtils.isSameLength(twoArrayLong, emptyArrayObject));
assertFalse(ArrayUtils.isSameLength(twoArrayLong, emptyArrayBoolean));
assertFalse(ArrayUtils.isSameLength(twoArrayLong, emptyArrayLong));
assertFalse(ArrayUtils.isSameLength(twoArrayLong, emptyArrayInt));
assertFalse(ArrayUtils.isSameLength(twoArrayLong, emptyArrayShort));
assertFalse(ArrayUtils.isSameLength(twoArrayLong, emptyArrayChar));
assertFalse(ArrayUtils.isSameLength(twoArrayLong, emptyArrayByte));
assertFalse(ArrayUtils.isSameLength(twoArrayLong, emptyArrayDouble));
assertFalse(ArrayUtils.isSameLength(twoArrayLong, emptyArrayFloat));
assertFalse(ArrayUtils.isSameLength(twoArrayInt, emptyArrayObject));
assertFalse(ArrayUtils.isSameLength(twoArrayInt, emptyArrayBoolean));
assertFalse(ArrayUtils.isSameLength(twoArrayInt, emptyArrayLong));
assertFalse(ArrayUtils.isSameLength(twoArrayInt, emptyArrayInt));
assertFalse(ArrayUtils.isSameLength(twoArrayInt, emptyArrayShort));
assertFalse(ArrayUtils.isSameLength(twoArrayInt, emptyArrayChar));
assertFalse(ArrayUtils.isSameLength(twoArrayInt, emptyArrayByte));
assertFalse(ArrayUtils.isSameLength(twoArrayInt, emptyArrayDouble));
assertFalse(ArrayUtils.isSameLength(twoArrayInt, emptyArrayFloat));
assertFalse(ArrayUtils.isSameLength(twoArrayShort, emptyArrayObject));
assertFalse(ArrayUtils.isSameLength(twoArrayShort, emptyArrayBoolean));
assertFalse(ArrayUtils.isSameLength(twoArrayShort, emptyArrayLong));
assertFalse(ArrayUtils.isSameLength(twoArrayShort, emptyArrayInt));
assertFalse(ArrayUtils.isSameLength(twoArrayShort, emptyArrayShort));
assertFalse(ArrayUtils.isSameLength(twoArrayShort, emptyArrayChar));
assertFalse(ArrayUtils.isSameLength(twoArrayShort, emptyArrayByte));
assertFalse(ArrayUtils.isSameLength(twoArrayShort, emptyArrayDouble));
assertFalse(ArrayUtils.isSameLength(twoArrayShort, emptyArrayFloat));
assertFalse(ArrayUtils.isSameLength(twoArrayChar, emptyArrayObject));
assertFalse(ArrayUtils.isSameLength(twoArrayChar, emptyArrayBoolean));
assertFalse(ArrayUtils.isSameLength(twoArrayChar, emptyArrayLong));
assertFalse(ArrayUtils.isSameLength(twoArrayChar, emptyArrayInt));
assertFalse(ArrayUtils.isSameLength(twoArrayChar, emptyArrayShort));
assertFalse(ArrayUtils.isSameLength(twoArrayChar, emptyArrayChar));
assertFalse(ArrayUtils.isSameLength(twoArrayChar, emptyArrayByte));
assertFalse(ArrayUtils.isSameLength(twoArrayChar, emptyArrayDouble));
assertFalse(ArrayUtils.isSameLength(twoArrayChar, emptyArrayFloat));
assertFalse(ArrayUtils.isSameLength(twoArrayByte, emptyArrayObject));
assertFalse(ArrayUtils.isSameLength(twoArrayByte, emptyArrayBoolean));
assertFalse(ArrayUtils.isSameLength(twoArrayByte, emptyArrayLong));
assertFalse(ArrayUtils.isSameLength(twoArrayByte, emptyArrayInt));
assertFalse(ArrayUtils.isSameLength(twoArrayByte, emptyArrayShort));
assertFalse(ArrayUtils.isSameLength(twoArrayByte, emptyArrayChar));
assertFalse(ArrayUtils.isSameLength(twoArrayByte, emptyArrayByte));
assertFalse(ArrayUtils.isSameLength(twoArrayByte, emptyArrayDouble));
assertFalse(ArrayUtils.isSameLength(twoArrayByte, emptyArrayFloat));
assertFalse(ArrayUtils.isSameLength(twoArrayDouble, emptyArrayObject));
assertFalse(ArrayUtils.isSameLength(twoArrayDouble, emptyArrayBoolean));
assertFalse(ArrayUtils.isSameLength(twoArrayDouble, emptyArrayLong));
assertFalse(ArrayUtils.isSameLength(twoArrayDouble, emptyArrayInt));
assertFalse(ArrayUtils.isSameLength(twoArrayDouble, emptyArrayShort));
assertFalse(ArrayUtils.isSameLength(twoArrayDouble, emptyArrayChar));
assertFalse(ArrayUtils.isSameLength(twoArrayDouble, emptyArrayByte));
assertFalse(ArrayUtils.isSameLength(twoArrayDouble, emptyArrayDouble));
assertFalse(ArrayUtils.isSameLength(twoArrayDouble, emptyArrayFloat));
assertFalse(ArrayUtils.isSameLength(twoArrayFloat, emptyArrayObject));
assertFalse(ArrayUtils.isSameLength(twoArrayFloat, emptyArrayBoolean));
assertFalse(ArrayUtils.isSameLength(twoArrayFloat, emptyArrayLong));
assertFalse(ArrayUtils.isSameLength(twoArrayFloat, emptyArrayInt));
assertFalse(ArrayUtils.isSameLength(twoArrayFloat, emptyArrayShort));
assertFalse(ArrayUtils.isSameLength(twoArrayFloat, emptyArrayChar));
assertFalse(ArrayUtils.isSameLength(twoArrayFloat, emptyArrayByte));
assertFalse(ArrayUtils.isSameLength(twoArrayFloat, emptyArrayDouble));
assertFalse(ArrayUtils.isSameLength(twoArrayFloat, emptyArrayFloat));
assertFalse(ArrayUtils.isSameLength(twoArrayObject, oneArrayObject));
assertFalse(ArrayUtils.isSameLength(twoArrayObject, oneArrayBoolean));
assertFalse(ArrayUtils.isSameLength(twoArrayObject, oneArrayLong));
assertFalse(ArrayUtils.isSameLength(twoArrayObject, oneArrayInt));
assertFalse(ArrayUtils.isSameLength(twoArrayObject, oneArrayShort));
assertFalse(ArrayUtils.isSameLength(twoArrayObject, oneArrayChar));
assertFalse(ArrayUtils.isSameLength(twoArrayObject, oneArrayByte));
assertFalse(ArrayUtils.isSameLength(twoArrayObject, oneArrayDouble));
assertFalse(ArrayUtils.isSameLength(twoArrayObject, oneArrayFloat));
assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, oneArrayObject));
assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, oneArrayBoolean));
assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, oneArrayLong));
assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, oneArrayInt));
assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, oneArrayShort));
assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, oneArrayChar));
assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, oneArrayByte));
assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, oneArrayDouble));
assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, oneArrayFloat));
assertFalse(ArrayUtils.isSameLength(twoArrayLong, oneArrayObject));
assertFalse(ArrayUtils.isSameLength(twoArrayLong, oneArrayBoolean));
assertFalse(ArrayUtils.isSameLength(twoArrayLong, oneArrayLong));
assertFalse(ArrayUtils.isSameLength(twoArrayLong, oneArrayInt));
assertFalse(ArrayUtils.isSameLength(twoArrayLong, oneArrayShort));
assertFalse(ArrayUtils.isSameLength(twoArrayLong, oneArrayChar));
assertFalse(ArrayUtils.isSameLength(twoArrayLong, oneArrayByte));
assertFalse(ArrayUtils.isSameLength(twoArrayLong, oneArrayDouble));
assertFalse(ArrayUtils.isSameLength(twoArrayLong, oneArrayFloat));
assertFalse(ArrayUtils.isSameLength(twoArrayInt, oneArrayObject));
assertFalse(ArrayUtils.isSameLength(twoArrayInt, oneArrayBoolean));
assertFalse(ArrayUtils.isSameLength(twoArrayInt, oneArrayLong));
assertFalse(ArrayUtils.isSameLength(twoArrayInt, oneArrayInt));
assertFalse(ArrayUtils.isSameLength(twoArrayInt, oneArrayShort));
assertFalse(ArrayUtils.isSameLength(twoArrayInt, oneArrayChar));
assertFalse(ArrayUtils.isSameLength(twoArrayInt, oneArrayByte));
assertFalse(ArrayUtils.isSameLength(twoArrayInt, oneArrayDouble));
assertFalse(ArrayUtils.isSameLength(twoArrayInt, oneArrayFloat));
assertFalse(ArrayUtils.isSameLength(twoArrayShort, oneArrayObject));
assertFalse(ArrayUtils.isSameLength(twoArrayShort, oneArrayBoolean));
assertFalse(ArrayUtils.isSameLength(twoArrayShort, oneArrayLong));
assertFalse(ArrayUtils.isSameLength(twoArrayShort, oneArrayInt));
assertFalse(ArrayUtils.isSameLength(twoArrayShort, oneArrayShort));
assertFalse(ArrayUtils.isSameLength(twoArrayShort, oneArrayChar));
assertFalse(ArrayUtils.isSameLength(twoArrayShort, oneArrayByte));
assertFalse(ArrayUtils.isSameLength(twoArrayShort, oneArrayDouble));
assertFalse(ArrayUtils.isSameLength(twoArrayShort, oneArrayFloat));
assertFalse(ArrayUtils.isSameLength(twoArrayChar, oneArrayObject));
assertFalse(ArrayUtils.isSameLength(twoArrayChar, oneArrayBoolean));
assertFalse(ArrayUtils.isSameLength(twoArrayChar, oneArrayLong));
assertFalse(ArrayUtils.isSameLength(twoArrayChar, oneArrayInt));
assertFalse(ArrayUtils.isSameLength(twoArrayChar, oneArrayShort));
assertFalse(ArrayUtils.isSameLength(twoArrayChar, oneArrayChar));
assertFalse(ArrayUtils.isSameLength(twoArrayChar, oneArrayByte));
assertFalse(ArrayUtils.isSameLength(twoArrayChar, oneArrayDouble));
assertFalse(ArrayUtils.isSameLength(twoArrayChar, oneArrayFloat));
assertFalse(ArrayUtils.isSameLength(twoArrayByte, oneArrayObject));
assertFalse(ArrayUtils.isSameLength(twoArrayByte, oneArrayBoolean));
assertFalse(ArrayUtils.isSameLength(twoArrayByte, oneArrayLong));
assertFalse(ArrayUtils.isSameLength(twoArrayByte, oneArrayInt));
assertFalse(ArrayUtils.isSameLength(twoArrayByte, oneArrayShort));
assertFalse(ArrayUtils.isSameLength(twoArrayByte, oneArrayChar));
assertFalse(ArrayUtils.isSameLength(twoArrayByte, oneArrayByte));
assertFalse(ArrayUtils.isSameLength(twoArrayByte, oneArrayDouble));
assertFalse(ArrayUtils.isSameLength(twoArrayByte, oneArrayFloat));
assertFalse(ArrayUtils.isSameLength(twoArrayDouble, oneArrayObject));
assertFalse(ArrayUtils.isSameLength(twoArrayDouble, oneArrayBoolean));
assertFalse(ArrayUtils.isSameLength(twoArrayDouble, oneArrayLong));
assertFalse(ArrayUtils.isSameLength(twoArrayDouble, oneArrayInt));
assertFalse(ArrayUtils.isSameLength(twoArrayDouble, oneArrayShort));
assertFalse(ArrayUtils.isSameLength(twoArrayDouble, oneArrayChar));
assertFalse(ArrayUtils.isSameLength(twoArrayDouble, oneArrayByte));
assertFalse(ArrayUtils.isSameLength(twoArrayDouble, oneArrayDouble));
assertFalse(ArrayUtils.isSameLength(twoArrayDouble, oneArrayFloat));
assertFalse(ArrayUtils.isSameLength(twoArrayFloat, oneArrayObject));
assertFalse(ArrayUtils.isSameLength(twoArrayFloat, oneArrayBoolean));
assertFalse(ArrayUtils.isSameLength(twoArrayFloat, oneArrayLong));
assertFalse(ArrayUtils.isSameLength(twoArrayFloat, oneArrayInt));
assertFalse(ArrayUtils.isSameLength(twoArrayFloat, oneArrayShort));
assertFalse(ArrayUtils.isSameLength(twoArrayFloat, oneArrayChar));
assertFalse(ArrayUtils.isSameLength(twoArrayFloat, oneArrayByte));
assertFalse(ArrayUtils.isSameLength(twoArrayFloat, oneArrayDouble));
assertFalse(ArrayUtils.isSameLength(twoArrayFloat, oneArrayFloat));
assertTrue(ArrayUtils.isSameLength(twoArrayObject, twoArrayObject));
assertTrue(ArrayUtils.isSameLength(twoArrayObject, twoArrayBoolean));
assertTrue(ArrayUtils.isSameLength(twoArrayObject, twoArrayLong));
assertTrue(ArrayUtils.isSameLength(twoArrayObject, twoArrayInt));
assertTrue(ArrayUtils.isSameLength(twoArrayObject, twoArrayShort));
assertTrue(ArrayUtils.isSameLength(twoArrayObject, twoArrayChar));
assertTrue(ArrayUtils.isSameLength(twoArrayObject, twoArrayByte));
assertTrue(ArrayUtils.isSameLength(twoArrayObject, twoArrayDouble));
assertTrue(ArrayUtils.isSameLength(twoArrayObject, twoArrayFloat));
assertTrue(ArrayUtils.isSameLength(twoArrayBoolean, twoArrayObject));
assertTrue(ArrayUtils.isSameLength(twoArrayBoolean, twoArrayBoolean));
assertTrue(ArrayUtils.isSameLength(twoArrayBoolean, twoArrayLong));
assertTrue(ArrayUtils.isSameLength(twoArrayBoolean, twoArrayInt));
assertTrue(ArrayUtils.isSameLength(twoArrayBoolean, twoArrayShort));
assertTrue(ArrayUtils.isSameLength(twoArrayBoolean, twoArrayChar));
assertTrue(ArrayUtils.isSameLength(twoArrayBoolean, twoArrayByte));
assertTrue(ArrayUtils.isSameLength(twoArrayBoolean, twoArrayDouble));
assertTrue(ArrayUtils.isSameLength(twoArrayBoolean, twoArrayFloat));
assertTrue(ArrayUtils.isSameLength(twoArrayLong, twoArrayObject));
assertTrue(ArrayUtils.isSameLength(twoArrayLong, twoArrayBoolean));
assertTrue(ArrayUtils.isSameLength(twoArrayLong, twoArrayLong));
assertTrue(ArrayUtils.isSameLength(twoArrayLong, twoArrayInt));
assertTrue(ArrayUtils.isSameLength(twoArrayLong, twoArrayShort));
assertTrue(ArrayUtils.isSameLength(twoArrayLong, twoArrayChar));
assertTrue(ArrayUtils.isSameLength(twoArrayLong, twoArrayByte));
assertTrue(ArrayUtils.isSameLength(twoArrayLong, twoArrayDouble));
assertTrue(ArrayUtils.isSameLength(twoArrayLong, twoArrayFloat));
assertTrue(ArrayUtils.isSameLength(twoArrayInt, twoArrayObject));
assertTrue(ArrayUtils.isSameLength(twoArrayInt, twoArrayBoolean));
assertTrue(ArrayUtils.isSameLength(twoArrayInt, twoArrayLong));
assertTrue(ArrayUtils.isSameLength(twoArrayInt, twoArrayInt));
assertTrue(ArrayUtils.isSameLength(twoArrayInt, twoArrayShort));
assertTrue(ArrayUtils.isSameLength(twoArrayInt, twoArrayChar));
assertTrue(ArrayUtils.isSameLength(twoArrayInt, twoArrayByte));
assertTrue(ArrayUtils.isSameLength(twoArrayInt, twoArrayDouble));
assertTrue(ArrayUtils.isSameLength(twoArrayInt, twoArrayFloat));
assertTrue(ArrayUtils.isSameLength(twoArrayShort, twoArrayObject));
assertTrue(ArrayUtils.isSameLength(twoArrayShort, twoArrayBoolean));
assertTrue(ArrayUtils.isSameLength(twoArrayShort, twoArrayLong));
assertTrue(ArrayUtils.isSameLength(twoArrayShort, twoArrayInt));
assertTrue(ArrayUtils.isSameLength(twoArrayShort, twoArrayShort));
assertTrue(ArrayUtils.isSameLength(twoArrayShort, twoArrayChar));
assertTrue(ArrayUtils.isSameLength(twoArrayShort, twoArrayByte));
assertTrue(ArrayUtils.isSameLength(twoArrayShort, twoArrayDouble));
assertTrue(ArrayUtils.isSameLength(twoArrayShort, twoArrayFloat));
assertTrue(ArrayUtils.isSameLength(twoArrayChar, twoArrayObject));
assertTrue(ArrayUtils.isSameLength(twoArrayChar, twoArrayBoolean));
assertTrue(ArrayUtils.isSameLength(twoArrayChar, twoArrayLong));
assertTrue(ArrayUtils.isSameLength(twoArrayChar, twoArrayInt));
assertTrue(ArrayUtils.isSameLength(twoArrayChar, twoArrayShort));
assertTrue(ArrayUtils.isSameLength(twoArrayChar, twoArrayChar));
assertTrue(ArrayUtils.isSameLength(twoArrayChar, twoArrayByte));
assertTrue(ArrayUtils.isSameLength(twoArrayChar, twoArrayDouble));
assertTrue(ArrayUtils.isSameLength(twoArrayChar, twoArrayFloat));
assertTrue(ArrayUtils.isSameLength(twoArrayByte, twoArrayObject));
assertTrue(ArrayUtils.isSameLength(twoArrayByte, twoArrayBoolean));
assertTrue(ArrayUtils.isSameLength(twoArrayByte, twoArrayLong));
assertTrue(ArrayUtils.isSameLength(twoArrayByte, twoArrayInt));
assertTrue(ArrayUtils.isSameLength(twoArrayByte, twoArrayShort));
assertTrue(ArrayUtils.isSameLength(twoArrayByte, twoArrayChar));
assertTrue(ArrayUtils.isSameLength(twoArrayByte, twoArrayByte));
assertTrue(ArrayUtils.isSameLength(twoArrayByte, twoArrayDouble));
assertTrue(ArrayUtils.isSameLength(twoArrayByte, twoArrayFloat));
assertTrue(ArrayUtils.isSameLength(twoArrayDouble, twoArrayObject));
assertTrue(ArrayUtils.isSameLength(twoArrayDouble, twoArrayBoolean));
assertTrue(ArrayUtils.isSameLength(twoArrayDouble, twoArrayLong));
assertTrue(ArrayUtils.isSameLength(twoArrayDouble, twoArrayInt));
assertTrue(ArrayUtils.isSameLength(twoArrayDouble, twoArrayShort));
assertTrue(ArrayUtils.isSameLength(twoArrayDouble, twoArrayChar));
assertTrue(ArrayUtils.isSameLength(twoArrayDouble, twoArrayByte));
assertTrue(ArrayUtils.isSameLength(twoArrayDouble, twoArrayDouble));
assertTrue(ArrayUtils.isSameLength(twoArrayDouble, twoArrayFloat));
assertTrue(ArrayUtils.isSameLength(twoArrayFloat, twoArrayObject));
assertTrue(ArrayUtils.isSameLength(twoArrayFloat, twoArrayBoolean));
assertTrue(ArrayUtils.isSameLength(twoArrayFloat, twoArrayLong));
assertTrue(ArrayUtils.isSameLength(twoArrayFloat, twoArrayInt));
assertTrue(ArrayUtils.isSameLength(twoArrayFloat, twoArrayShort));
assertTrue(ArrayUtils.isSameLength(twoArrayFloat, twoArrayChar));
assertTrue(ArrayUtils.isSameLength(twoArrayFloat, twoArrayByte));
assertTrue(ArrayUtils.isSameLength(twoArrayFloat, twoArrayDouble));
assertTrue(ArrayUtils.isSameLength(twoArrayFloat, twoArrayFloat));
}
@Test
void testSameLengthBoolean() {
final boolean[] nullArray = null;
final boolean[] emptyArray = {};
final boolean[] oneArray = {true};
final boolean[] twoArray = {true, false};
assertTrue(ArrayUtils.isSameLength(nullArray, nullArray));
assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray));
assertFalse(ArrayUtils.isSameLength(nullArray, oneArray));
assertFalse(ArrayUtils.isSameLength(nullArray, twoArray));
assertTrue(ArrayUtils.isSameLength(emptyArray, nullArray));
assertTrue(ArrayUtils.isSameLength(emptyArray, emptyArray));
assertFalse(ArrayUtils.isSameLength(emptyArray, oneArray));
assertFalse(ArrayUtils.isSameLength(emptyArray, twoArray));
assertFalse(ArrayUtils.isSameLength(oneArray, nullArray));
assertFalse(ArrayUtils.isSameLength(oneArray, emptyArray));
assertTrue(ArrayUtils.isSameLength(oneArray, oneArray));
assertFalse(ArrayUtils.isSameLength(oneArray, twoArray));
assertFalse(ArrayUtils.isSameLength(twoArray, nullArray));
assertFalse(ArrayUtils.isSameLength(twoArray, emptyArray));
assertFalse(ArrayUtils.isSameLength(twoArray, oneArray));
assertTrue(ArrayUtils.isSameLength(twoArray, twoArray));
}
@Test
void testSameLengthByte() {
final byte[] nullArray = null;
final byte[] emptyArray = {};
final byte[] oneArray = {3};
final byte[] twoArray = {4, 6};
assertTrue(ArrayUtils.isSameLength(nullArray, nullArray));
assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray));
assertFalse(ArrayUtils.isSameLength(nullArray, oneArray));
assertFalse(ArrayUtils.isSameLength(nullArray, twoArray));
assertTrue(ArrayUtils.isSameLength(emptyArray, nullArray));
assertTrue(ArrayUtils.isSameLength(emptyArray, emptyArray));
assertFalse(ArrayUtils.isSameLength(emptyArray, oneArray));
assertFalse(ArrayUtils.isSameLength(emptyArray, twoArray));
assertFalse(ArrayUtils.isSameLength(oneArray, nullArray));
assertFalse(ArrayUtils.isSameLength(oneArray, emptyArray));
assertTrue(ArrayUtils.isSameLength(oneArray, oneArray));
assertFalse(ArrayUtils.isSameLength(oneArray, twoArray));
assertFalse(ArrayUtils.isSameLength(twoArray, nullArray));
assertFalse(ArrayUtils.isSameLength(twoArray, emptyArray));
assertFalse(ArrayUtils.isSameLength(twoArray, oneArray));
assertTrue(ArrayUtils.isSameLength(twoArray, twoArray));
}
@Test
void testSameLengthChar() {
final char[] nullArray = null;
final char[] emptyArray = {};
final char[] oneArray = {'f'};
final char[] twoArray = {'d', 't'};
assertTrue(ArrayUtils.isSameLength(nullArray, nullArray));
assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray));
assertFalse(ArrayUtils.isSameLength(nullArray, oneArray));
assertFalse(ArrayUtils.isSameLength(nullArray, twoArray));
assertTrue(ArrayUtils.isSameLength(emptyArray, nullArray));
assertTrue(ArrayUtils.isSameLength(emptyArray, emptyArray));
assertFalse(ArrayUtils.isSameLength(emptyArray, oneArray));
assertFalse(ArrayUtils.isSameLength(emptyArray, twoArray));
assertFalse(ArrayUtils.isSameLength(oneArray, nullArray));
assertFalse(ArrayUtils.isSameLength(oneArray, emptyArray));
assertTrue(ArrayUtils.isSameLength(oneArray, oneArray));
assertFalse(ArrayUtils.isSameLength(oneArray, twoArray));
assertFalse(ArrayUtils.isSameLength(twoArray, nullArray));
assertFalse(ArrayUtils.isSameLength(twoArray, emptyArray));
assertFalse(ArrayUtils.isSameLength(twoArray, oneArray));
assertTrue(ArrayUtils.isSameLength(twoArray, twoArray));
}
@Test
void testSameLengthDouble() {
final double[] nullArray = null;
final double[] emptyArray = {};
final double[] oneArray = {1.3d};
final double[] twoArray = {4.5d, 6.3d};
assertTrue(ArrayUtils.isSameLength(nullArray, nullArray));
assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray));
assertFalse(ArrayUtils.isSameLength(nullArray, oneArray));
assertFalse(ArrayUtils.isSameLength(nullArray, twoArray));
assertTrue(ArrayUtils.isSameLength(emptyArray, nullArray));
assertTrue(ArrayUtils.isSameLength(emptyArray, emptyArray));
assertFalse(ArrayUtils.isSameLength(emptyArray, oneArray));
assertFalse(ArrayUtils.isSameLength(emptyArray, twoArray));
assertFalse(ArrayUtils.isSameLength(oneArray, nullArray));
assertFalse(ArrayUtils.isSameLength(oneArray, emptyArray));
assertTrue(ArrayUtils.isSameLength(oneArray, oneArray));
assertFalse(ArrayUtils.isSameLength(oneArray, twoArray));
assertFalse(ArrayUtils.isSameLength(twoArray, nullArray));
assertFalse(ArrayUtils.isSameLength(twoArray, emptyArray));
assertFalse(ArrayUtils.isSameLength(twoArray, oneArray));
assertTrue(ArrayUtils.isSameLength(twoArray, twoArray));
}
@Test
void testSameLengthFloat() {
final float[] nullArray = null;
final float[] emptyArray = {};
final float[] oneArray = {2.5f};
final float[] twoArray = {6.4f, 5.8f};
assertTrue(ArrayUtils.isSameLength(nullArray, nullArray));
assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray));
assertFalse(ArrayUtils.isSameLength(nullArray, oneArray));
assertFalse(ArrayUtils.isSameLength(nullArray, twoArray));
assertTrue(ArrayUtils.isSameLength(emptyArray, nullArray));
assertTrue(ArrayUtils.isSameLength(emptyArray, emptyArray));
assertFalse(ArrayUtils.isSameLength(emptyArray, oneArray));
assertFalse(ArrayUtils.isSameLength(emptyArray, twoArray));
assertFalse(ArrayUtils.isSameLength(oneArray, nullArray));
assertFalse(ArrayUtils.isSameLength(oneArray, emptyArray));
assertTrue(ArrayUtils.isSameLength(oneArray, oneArray));
assertFalse(ArrayUtils.isSameLength(oneArray, twoArray));
assertFalse(ArrayUtils.isSameLength(twoArray, nullArray));
assertFalse(ArrayUtils.isSameLength(twoArray, emptyArray));
assertFalse(ArrayUtils.isSameLength(twoArray, oneArray));
assertTrue(ArrayUtils.isSameLength(twoArray, twoArray));
}
@Test
void testSameLengthInt() {
final int[] nullArray = null;
final int[] emptyArray = {};
final int[] oneArray = {4};
final int[] twoArray = {5, 7};
assertTrue(ArrayUtils.isSameLength(nullArray, nullArray));
assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray));
assertFalse(ArrayUtils.isSameLength(nullArray, oneArray));
assertFalse(ArrayUtils.isSameLength(nullArray, twoArray));
assertTrue(ArrayUtils.isSameLength(emptyArray, nullArray));
assertTrue(ArrayUtils.isSameLength(emptyArray, emptyArray));
assertFalse(ArrayUtils.isSameLength(emptyArray, oneArray));
assertFalse(ArrayUtils.isSameLength(emptyArray, twoArray));
assertFalse(ArrayUtils.isSameLength(oneArray, nullArray));
assertFalse(ArrayUtils.isSameLength(oneArray, emptyArray));
assertTrue(ArrayUtils.isSameLength(oneArray, oneArray));
assertFalse(ArrayUtils.isSameLength(oneArray, twoArray));
assertFalse(ArrayUtils.isSameLength(twoArray, nullArray));
assertFalse(ArrayUtils.isSameLength(twoArray, emptyArray));
assertFalse(ArrayUtils.isSameLength(twoArray, oneArray));
assertTrue(ArrayUtils.isSameLength(twoArray, twoArray));
}
@Test
void testSameLengthLong() {
final long[] nullArray = null;
final long[] emptyArray = {};
final long[] oneArray = {0L};
final long[] twoArray = {0L, 76L};
assertTrue(ArrayUtils.isSameLength(nullArray, nullArray));
assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray));
assertFalse(ArrayUtils.isSameLength(nullArray, oneArray));
assertFalse(ArrayUtils.isSameLength(nullArray, twoArray));
assertTrue(ArrayUtils.isSameLength(emptyArray, nullArray));
assertTrue(ArrayUtils.isSameLength(emptyArray, emptyArray));
assertFalse(ArrayUtils.isSameLength(emptyArray, oneArray));
assertFalse(ArrayUtils.isSameLength(emptyArray, twoArray));
assertFalse(ArrayUtils.isSameLength(oneArray, nullArray));
assertFalse(ArrayUtils.isSameLength(oneArray, emptyArray));
assertTrue(ArrayUtils.isSameLength(oneArray, oneArray));
assertFalse(ArrayUtils.isSameLength(oneArray, twoArray));
assertFalse(ArrayUtils.isSameLength(twoArray, nullArray));
assertFalse(ArrayUtils.isSameLength(twoArray, emptyArray));
assertFalse(ArrayUtils.isSameLength(twoArray, oneArray));
assertTrue(ArrayUtils.isSameLength(twoArray, twoArray));
}
@Test
void testSameLengthShort() {
final short[] nullArray = null;
final short[] emptyArray = {};
final short[] oneArray = {4};
final short[] twoArray = {6, 8};
assertTrue(ArrayUtils.isSameLength(nullArray, nullArray));
assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray));
assertFalse(ArrayUtils.isSameLength(nullArray, oneArray));
assertFalse(ArrayUtils.isSameLength(nullArray, twoArray));
assertTrue(ArrayUtils.isSameLength(emptyArray, nullArray));
assertTrue(ArrayUtils.isSameLength(emptyArray, emptyArray));
assertFalse(ArrayUtils.isSameLength(emptyArray, oneArray));
assertFalse(ArrayUtils.isSameLength(emptyArray, twoArray));
assertFalse(ArrayUtils.isSameLength(oneArray, nullArray));
assertFalse(ArrayUtils.isSameLength(oneArray, emptyArray));
assertTrue(ArrayUtils.isSameLength(oneArray, oneArray));
assertFalse(ArrayUtils.isSameLength(oneArray, twoArray));
assertFalse(ArrayUtils.isSameLength(twoArray, nullArray));
assertFalse(ArrayUtils.isSameLength(twoArray, emptyArray));
assertFalse(ArrayUtils.isSameLength(twoArray, oneArray));
assertTrue(ArrayUtils.isSameLength(twoArray, twoArray));
}
@Test
void testSameType() {
assertIllegalArgumentException(() -> ArrayUtils.isSameType(null, null));
assertIllegalArgumentException(() -> ArrayUtils.isSameType(null, new Object[0]));
assertIllegalArgumentException(() -> ArrayUtils.isSameType(new Object[0], null));
assertTrue(ArrayUtils.isSameType(new Object[0], new Object[0]));
assertFalse(ArrayUtils.isSameType(new String[0], new Object[0]));
assertTrue(ArrayUtils.isSameType(new String[0][0], new String[0][0]));
assertFalse(ArrayUtils.isSameType(new String[0], new String[0][0]));
assertFalse(ArrayUtils.isSameType(new String[0][0], new String[0]));
}
@Test
void testShiftAllByte() {
final byte[] array = {1, 2, 3, 4};
ArrayUtils.shift(array, 4);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
assertEquals(3, array[2]);
assertEquals(4, array[3]);
ArrayUtils.shift(array, -4);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
assertEquals(3, array[2]);
assertEquals(4, array[3]);
}
@Test
void testShiftAllChar() {
final char[] array = {1, 2, 3, 4};
ArrayUtils.shift(array, 4);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
assertEquals(3, array[2]);
assertEquals(4, array[3]);
ArrayUtils.shift(array, -4);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
assertEquals(3, array[2]);
assertEquals(4, array[3]);
}
@Test
void testShiftAllDouble() {
final double[] array = {1, 2, 3, 4};
ArrayUtils.shift(array, 4);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
assertEquals(3, array[2]);
assertEquals(4, array[3]);
ArrayUtils.shift(array, -4);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
assertEquals(3, array[2]);
assertEquals(4, array[3]);
}
@Test
void testShiftAllFloat() {
final float[] array = {1, 2, 3, 4};
ArrayUtils.shift(array, 4);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
assertEquals(3, array[2]);
assertEquals(4, array[3]);
ArrayUtils.shift(array, -4);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
assertEquals(3, array[2]);
assertEquals(4, array[3]);
}
@Test
void testShiftAllInt() {
final int[] array = {1, 2, 3, 4};
ArrayUtils.shift(array, 4);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
assertEquals(3, array[2]);
assertEquals(4, array[3]);
ArrayUtils.shift(array, -4);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
assertEquals(3, array[2]);
assertEquals(4, array[3]);
}
@Test
void testShiftAllLong() {
final long[] array = {1, 2, 3, 4};
ArrayUtils.shift(array, 4);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
assertEquals(3, array[2]);
assertEquals(4, array[3]);
ArrayUtils.shift(array, -4);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
assertEquals(3, array[2]);
assertEquals(4, array[3]);
}
@Test
void testShiftAllObject() {
final String[] array = {"1", "2", "3", "4"};
ArrayUtils.shift(array, 4);
assertEquals("1", array[0]);
assertEquals("2", array[1]);
assertEquals("3", array[2]);
assertEquals("4", array[3]);
ArrayUtils.shift(array, -4);
assertEquals("1", array[0]);
assertEquals("2", array[1]);
assertEquals("3", array[2]);
assertEquals("4", array[3]);
}
@Test
void testShiftAllShort() {
final short[] array = {1, 2, 3, 4};
ArrayUtils.shift(array, 4);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
assertEquals(3, array[2]);
assertEquals(4, array[3]);
ArrayUtils.shift(array, -4);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
assertEquals(3, array[2]);
assertEquals(4, array[3]);
}
@Test
void testShiftBoolean() {
ArrayUtils.shift(new boolean[0], 1);
final boolean[] array = { true, true, false, false };
ArrayUtils.shift(array, 1);
assertFalse(array[0]);
assertTrue(array[1]);
assertTrue(array[2]);
assertFalse(array[3]);
ArrayUtils.shift(array, -1);
assertTrue(array[0]);
assertTrue(array[1]);
assertFalse(array[2]);
assertFalse(array[3]);
ArrayUtils.shift(array, 5);
assertFalse(array[0]);
assertTrue(array[1]);
assertTrue(array[2]);
assertFalse(array[3]);
ArrayUtils.shift(array, -3);
assertFalse(array[0]);
assertFalse(array[1]);
assertTrue(array[2]);
assertTrue(array[3]);
}
@Test
void testShiftBooleanArrayNull() {
final boolean[] array = null;
ArrayUtils.shift(array, 1);
assertNull(array);
}
@Test
void testShiftByte() {
ArrayUtils.shift((byte[]) null, 1);
ArrayUtils.shift(new byte[0], 1);
final byte[] array = { 1, 2, 3, 4 };
ArrayUtils.shift(array, 1);
assertEquals(4, array[0]);
assertEquals(1, array[1]);
assertEquals(2, array[2]);
assertEquals(3, array[3]);
ArrayUtils.shift(array, -1);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
assertEquals(3, array[2]);
assertEquals(4, array[3]);
ArrayUtils.shift(array, 5);
assertEquals(4, array[0]);
assertEquals(1, array[1]);
assertEquals(2, array[2]);
assertEquals(3, array[3]);
ArrayUtils.shift(array, -3);
assertEquals(3, array[0]);
assertEquals(4, array[1]);
assertEquals(1, array[2]);
assertEquals(2, array[3]);
}
@Test
void testShiftChar() {
ArrayUtils.shift((char[]) null, 1);
final char[] array = {1, 2, 3, 4};
ArrayUtils.shift(array, 1);
assertEquals(4, array[0]);
assertEquals(1, array[1]);
assertEquals(2, array[2]);
assertEquals(3, array[3]);
ArrayUtils.shift(array, -1);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
assertEquals(3, array[2]);
assertEquals(4, array[3]);
ArrayUtils.shift(array, 5);
assertEquals(4, array[0]);
assertEquals(1, array[1]);
assertEquals(2, array[2]);
assertEquals(3, array[3]);
ArrayUtils.shift(array, -3);
assertEquals(3, array[0]);
assertEquals(4, array[1]);
assertEquals(1, array[2]);
assertEquals(2, array[3]);
}
@Test
void testShiftDouble() {
ArrayUtils.shift((double[]) null, 1);
final double[] array = {1, 2, 3, 4};
ArrayUtils.shift(array, 1);
assertEquals(4, array[0]);
assertEquals(1, array[1]);
assertEquals(2, array[2]);
assertEquals(3, array[3]);
ArrayUtils.shift(array, -1);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
assertEquals(3, array[2]);
assertEquals(4, array[3]);
ArrayUtils.shift(array, 5);
assertEquals(4, array[0]);
assertEquals(1, array[1]);
assertEquals(2, array[2]);
assertEquals(3, array[3]);
ArrayUtils.shift(array, -3);
assertEquals(3, array[0]);
assertEquals(4, array[1]);
assertEquals(1, array[2]);
assertEquals(2, array[3]);
}
@Test
void testShiftDoubleArrayNull() {
final double[] array = null;
ArrayUtils.shift(array, 1);
assertNull(array);
}
@Test
void testShiftFloat() {
ArrayUtils.shift((float[]) null, 1);
final float[] array = {1, 2, 3, 4};
ArrayUtils.shift(array, 1);
assertEquals(4, array[0]);
assertEquals(1, array[1]);
assertEquals(2, array[2]);
assertEquals(3, array[3]);
ArrayUtils.shift(array, -1);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
assertEquals(3, array[2]);
assertEquals(4, array[3]);
ArrayUtils.shift(array, 5);
assertEquals(4, array[0]);
assertEquals(1, array[1]);
assertEquals(2, array[2]);
assertEquals(3, array[3]);
ArrayUtils.shift(array, -3);
assertEquals(3, array[0]);
assertEquals(4, array[1]);
assertEquals(1, array[2]);
assertEquals(2, array[3]);
}
@Test
void testShiftFloatArrayNull() {
final float[] array = null;
ArrayUtils.shift(array, 1);
assertNull(array);
}
@Test
void testShiftInt() {
ArrayUtils.shift((int[]) null, 1);
final int[] array = {1, 2, 3, 4};
ArrayUtils.shift(array, 1);
assertEquals(4, array[0]);
assertEquals(1, array[1]);
assertEquals(2, array[2]);
assertEquals(3, array[3]);
ArrayUtils.shift(array, -1);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
assertEquals(3, array[2]);
assertEquals(4, array[3]);
ArrayUtils.shift(array, 5);
assertEquals(4, array[0]);
assertEquals(1, array[1]);
assertEquals(2, array[2]);
assertEquals(3, array[3]);
ArrayUtils.shift(array, -3);
assertEquals(3, array[0]);
assertEquals(4, array[1]);
assertEquals(1, array[2]);
assertEquals(2, array[3]);
}
@Test
void testShiftIntArrayNull() {
final int[] array = null;
ArrayUtils.shift(array, 1);
assertNull(array);
}
@Test
void testShiftLong() {
ArrayUtils.shift((long[]) null, 1);
final long[] array = {1, 2, 3, 4};
ArrayUtils.shift(array, 1);
assertEquals(4, array[0]);
assertEquals(1, array[1]);
assertEquals(2, array[2]);
assertEquals(3, array[3]);
ArrayUtils.shift(array, -1);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
assertEquals(3, array[2]);
assertEquals(4, array[3]);
ArrayUtils.shift(array, 5);
assertEquals(4, array[0]);
assertEquals(1, array[1]);
assertEquals(2, array[2]);
assertEquals(3, array[3]);
ArrayUtils.shift(array, -3);
assertEquals(3, array[0]);
assertEquals(4, array[1]);
assertEquals(1, array[2]);
assertEquals(2, array[3]);
}
@Test
void testShiftLongArrayNull() {
final long[] array = null;
ArrayUtils.shift(array, 1);
assertNull(array);
}
@Test
void testShiftObject() {
ArrayUtils.shift((String[]) null, 1);
final String[] array = {"1", "2", "3", "4"};
ArrayUtils.shift(array, 1);
assertEquals("4", array[0]);
assertEquals("1", array[1]);
assertEquals("2", array[2]);
assertEquals("3", array[3]);
ArrayUtils.shift(array, -1);
assertEquals("1", array[0]);
assertEquals("2", array[1]);
assertEquals("3", array[2]);
assertEquals("4", array[3]);
ArrayUtils.shift(array, 5);
assertEquals("4", array[0]);
assertEquals("1", array[1]);
assertEquals("2", array[2]);
assertEquals("3", array[3]);
ArrayUtils.shift(array, -3);
assertEquals("3", array[0]);
assertEquals("4", array[1]);
assertEquals("1", array[2]);
assertEquals("2", array[3]);
}
@Test
void testShiftObjectArrayNull() {
final String[] array = null;
ArrayUtils.shift(array, 1);
assertNull(array);
}
@Test
void testShiftRangeBoolean() {
// edge cases where nothing happens
// (1) array == null
ArrayUtils.shift((boolean[]) null, 0, 0, 0);
// (2) startIndexInclusive >= array.length - 1
ArrayUtils.shift(new boolean[0], 100, 0, 0);
// (3) endIndexExclusive <= 0
final boolean[] array1 = { true };
ArrayUtils.shift(array1, -1, 0, 0);
assertArrayEquals(new boolean[] { true }, array1);
// (4) n <= 1
final boolean[] array2 = { true, false, true };
ArrayUtils.shift(array2, 1, 1, 0);
assertArrayEquals(new boolean[] { true, false, true }, array2);
// tests
final boolean[] array = {true, false, false, false, true};
ArrayUtils.shift(array, 1, 3, 1);
assertEquals(true, array[0]);
assertEquals(false, array[1]);
assertEquals(false, array[2]);
assertEquals(false, array[3]);
assertEquals(true, array[4]);
ArrayUtils.shift(array, 1, 4, 2);
assertEquals(true, array[0]);
assertEquals(false, array[1]);
assertEquals(false, array[2]);
assertEquals(false, array[3]);
assertEquals(true, array[4]);
}
@Test
void testShiftRangeByte() {
// edge cases where nothing happens
// (1) array == null
ArrayUtils.shift((byte[]) null, 0, 0, 0);
// (2) startIndexInclusive >= array.length - 1
ArrayUtils.shift(new byte[0], 100, 0, 0);
// (3) endIndexExclusive <= 0
final byte[] array1 = { 1 };
ArrayUtils.shift(array1, -1, 0, 0);
assertArrayEquals(new byte[] { 1 }, array1);
// (4) n <= 1
final byte[] array2 = { 1, 0, 1 };
ArrayUtils.shift(array2, 1, 1, 0);
assertArrayEquals(new byte[] { 1, 0, 1 }, array2);
// tests
final byte[] array = {1, 2, 3, 4, 5};
ArrayUtils.shift(array, 1, 3, 1);
assertEquals(1, array[0]);
assertEquals(3, array[1]);
assertEquals(2, array[2]);
assertEquals(4, array[3]);
assertEquals(5, array[4]);
ArrayUtils.shift(array, 1, 4, 2);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
assertEquals(4, array[2]);
assertEquals(3, array[3]);
assertEquals(5, array[4]);
}
@Test
void testShiftRangeChar() {
// edge cases where nothing happens
// (1) array == null
ArrayUtils.shift((char[]) null, 0, 0, 0);
// (2) startIndexInclusive >= array.length - 1
ArrayUtils.shift(new char[0], 100, 0, 0);
// (3) endIndexExclusive <= 0
final char[] array1 = { 1 };
ArrayUtils.shift(array1, -1, 0, 0);
assertArrayEquals(new char[] { 1 }, array1);
// (4) n <= 1
final char[] array2 = { 1, 0, 1 };
ArrayUtils.shift(array2, 1, 1, 0);
assertArrayEquals(new char[] { 1, 0, 1 }, array2);
// tests
final char[] array = {1, 2, 3, 4, 5};
ArrayUtils.shift(array, 1, 3, 1);
assertEquals(1, array[0]);
assertEquals(3, array[1]);
assertEquals(2, array[2]);
assertEquals(4, array[3]);
assertEquals(5, array[4]);
ArrayUtils.shift(array, 1, 4, 2);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
assertEquals(4, array[2]);
assertEquals(3, array[3]);
assertEquals(5, array[4]);
}
@Test
void testShiftRangeDouble() {
// edge cases where nothing happens
// (1) array == null
ArrayUtils.shift((double[]) null, 0, 0, 0);
// (2) startIndexInclusive >= array.length - 1
ArrayUtils.shift(new double[0], 100, 0, 0);
// (3) endIndexExclusive <= 0
final double[] array1 = { 1 };
ArrayUtils.shift(array1, -1, 0, 0);
assertArrayEquals(new double[] { 1 }, array1);
// (4) n <= 1
final double[] array2 = { 1, 0, 1 };
ArrayUtils.shift(array2, 1, 1, 0);
assertArrayEquals(new double[] { 1, 0, 1 }, array2);
// tests
final double[] array = {1, 2, 3, 4, 5};
ArrayUtils.shift(array, 1, 3, 1);
assertEquals(1, array[0]);
assertEquals(3, array[1]);
assertEquals(2, array[2]);
assertEquals(4, array[3]);
assertEquals(5, array[4]);
ArrayUtils.shift(array, 1, 4, 2);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
assertEquals(4, array[2]);
assertEquals(3, array[3]);
assertEquals(5, array[4]);
}
@Test
void testShiftRangeFloat() {
// edge cases where nothing happens
// (1) array == null
ArrayUtils.shift((float[]) null, 0, 0, 0);
// (2) startIndexInclusive >= array.length - 1
ArrayUtils.shift(new float[0], 100, 0, 0);
// (3) endIndexExclusive <= 0
final float[] array1 = { 1 };
ArrayUtils.shift(array1, -1, 0, 0);
assertArrayEquals(new float[] { 1 }, array1);
// (4) n <= 1
final float[] array2 = { 1, 0, 1 };
ArrayUtils.shift(array2, 1, 1, 0);
assertArrayEquals(new float[] { 1, 0, 1 }, array2);
// tests
final float[] array = {1, 2, 3, 4, 5};
ArrayUtils.shift(array, 1, 3, 1);
assertEquals(1, array[0]);
assertEquals(3, array[1]);
assertEquals(2, array[2]);
assertEquals(4, array[3]);
assertEquals(5, array[4]);
ArrayUtils.shift(array, 1, 4, 2);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
assertEquals(4, array[2]);
assertEquals(3, array[3]);
assertEquals(5, array[4]);
}
@Test
void testShiftRangeInt() {
// edge cases where nothing happens
// (1) array == null
ArrayUtils.shift((int[]) null, 0, 0, 0);
// (2) startIndexInclusive >= array.length - 1
ArrayUtils.shift(new int[0], 100, 0, 0);
// (3) endIndexExclusive <= 0
final int[] array1 = { 1 };
ArrayUtils.shift(array1, -1, 0, 0);
assertArrayEquals(new int[] { 1 }, array1);
// (4) n <= 1
final int[] array2 = { 1, 0, 1 };
ArrayUtils.shift(array2, 1, 1, 0);
assertArrayEquals(new int[] { 1, 0, 1 }, array2);
// tests
final int[] array = {1, 2, 3, 4, 5};
ArrayUtils.shift(array, 1, 3, 1);
assertEquals(1, array[0]);
assertEquals(3, array[1]);
assertEquals(2, array[2]);
assertEquals(4, array[3]);
assertEquals(5, array[4]);
ArrayUtils.shift(array, 1, 4, 2);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
assertEquals(4, array[2]);
assertEquals(3, array[3]);
assertEquals(5, array[4]);
}
@Test
void testShiftRangeLong() {
// edge cases where nothing happens
// (1) array == null
ArrayUtils.shift((long[]) null, 0, 0, 0);
// (2) startIndexInclusive >= array.length - 1
ArrayUtils.shift(new long[0], 100, 0, 0);
// (3) endIndexExclusive <= 0
final long[] array1 = { 1 };
ArrayUtils.shift(array1, -1, 0, 0);
assertArrayEquals(new long[] { 1 }, array1);
// (4) n <= 1
final long[] array2 = { 1, 0, 1 };
ArrayUtils.shift(array2, 1, 1, 0);
assertArrayEquals(new long[] { 1, 0, 1 }, array2);
// tests
final long[] array = {1, 2, 3, 4, 5};
ArrayUtils.shift(array, 1, 3, 1);
assertEquals(1, array[0]);
assertEquals(3, array[1]);
assertEquals(2, array[2]);
assertEquals(4, array[3]);
assertEquals(5, array[4]);
ArrayUtils.shift(array, 1, 4, 2);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
assertEquals(4, array[2]);
assertEquals(3, array[3]);
assertEquals(5, array[4]);
}
@Test
void testShiftRangeNoElemByte() {
final byte[] array = {1, 2, 3, 4};
ArrayUtils.shift(array, 1, 1, 1);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
assertEquals(3, array[2]);
assertEquals(4, array[3]);
}
@Test
void testShiftRangeNoElemChar() {
final char[] array = {1, 2, 3, 4};
ArrayUtils.shift(array, 1, 1, 1);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
assertEquals(3, array[2]);
assertEquals(4, array[3]);
}
@Test
void testShiftRangeNoElemDouble() {
final double[] array = {1, 2, 3, 4};
ArrayUtils.shift(array, 1, 1, 1);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
assertEquals(3, array[2]);
assertEquals(4, array[3]);
}
@Test
void testShiftRangeNoElemFloat() {
final float[] array = {1, 2, 3, 4};
ArrayUtils.shift(array, 1, 1, 1);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
assertEquals(3, array[2]);
assertEquals(4, array[3]);
}
@Test
void testShiftRangeNoElemInt() {
final int[] array = {1, 2, 3, 4};
ArrayUtils.shift(array, 1, 1, 1);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
assertEquals(3, array[2]);
assertEquals(4, array[3]);
}
@Test
void testShiftRangeNoElemLong() {
final long[] array = {1, 2, 3, 4};
ArrayUtils.shift(array, 1, 1, 1);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
assertEquals(3, array[2]);
assertEquals(4, array[3]);
}
@Test
void testShiftRangeNoElemObject() {
final String[] array = {"1", "2", "3", "4"};
ArrayUtils.shift(array, 1, 1, 1);
assertEquals("1", array[0]);
assertEquals("2", array[1]);
assertEquals("3", array[2]);
assertEquals("4", array[3]);
}
@Test
void testShiftRangeNoElemShort() {
final short[] array = {1, 2, 3, 4};
ArrayUtils.shift(array, 1, 1, 1);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
assertEquals(3, array[2]);
assertEquals(4, array[3]);
}
@Test
void testShiftRangeNullByte() {
final byte[] array = null;
ArrayUtils.shift(array, 1, 1, 1);
assertNull(array);
}
@Test
void testShiftRangeNullChar() {
final char[] array = null;
ArrayUtils.shift(array, 1, 1, 1);
assertNull(array);
}
@Test
void testShiftRangeNullDouble() {
final double[] array = null;
ArrayUtils.shift(array, 1, 1, 1);
assertNull(array);
}
@Test
void testShiftRangeNullFloat() {
final float[] array = null;
ArrayUtils.shift(array, 1, 1, 1);
assertNull(array);
}
@Test
void testShiftRangeNullInt() {
final int[] array = null;
ArrayUtils.shift(array, 1, 1, 1);
assertNull(array);
}
@Test
void testShiftRangeNullLong() {
final long[] array = null;
ArrayUtils.shift(array, 1, 1, 1);
assertNull(array);
}
@Test
void testShiftRangeNullObject() {
final String[] array = null;
ArrayUtils.shift(array, 1, 1, 1);
assertNull(array);
}
@Test
void testShiftRangeNullShort() {
final short[] array = null;
ArrayUtils.shift(array, 1, 1, 1);
assertNull(array);
}
@Test
void testShiftRangeObject() {
final String[] array = {"1", "2", "3", "4", "5"};
ArrayUtils.shift(array, 1, 3, 1);
assertEquals("1", array[0]);
assertEquals("3", array[1]);
assertEquals("2", array[2]);
assertEquals("4", array[3]);
assertEquals("5", array[4]);
ArrayUtils.shift(array, 1, 4, 2);
assertEquals("1", array[0]);
assertEquals("2", array[1]);
assertEquals("4", array[2]);
assertEquals("3", array[3]);
assertEquals("5", array[4]);
}
@Test
void testShiftRangeShort() {
// edge cases where nothing happens
// (1) array == null
ArrayUtils.shift((short[]) null, 0, 0, 0);
// (2) startIndexInclusive >= array.length - 1
ArrayUtils.shift(new short[0], 100, 0, 0);
// (3) endIndexExclusive <= 0
final short[] array1 = { 1 };
ArrayUtils.shift(array1, -1, 0, 0);
assertArrayEquals(new short[] { 1 }, array1);
// (4) n <= 1
final short[] array2 = { 1, 0, 1 };
ArrayUtils.shift(array2, 1, 1, 0);
assertArrayEquals(new short[] { 1, 0, 1 }, array2);
// tests
final short[] array = {1, 2, 3, 4, 5};
ArrayUtils.shift(array, 1, 3, 1);
assertEquals(1, array[0]);
assertEquals(3, array[1]);
assertEquals(2, array[2]);
assertEquals(4, array[3]);
assertEquals(5, array[4]);
ArrayUtils.shift(array, 1, 4, 2);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
assertEquals(4, array[2]);
assertEquals(3, array[3]);
assertEquals(5, array[4]);
}
@Test
void testShiftShort() {
ArrayUtils.shift((short[]) null, 1);
short[] array = {1, 2, 3, 4};
ArrayUtils.shift(array, 1);
assertEquals(4, array[0]);
assertEquals(1, array[1]);
assertEquals(2, array[2]);
assertEquals(3, array[3]);
ArrayUtils.shift(array, -1);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
assertEquals(3, array[2]);
assertEquals(4, array[3]);
ArrayUtils.shift(array, 5);
assertEquals(4, array[0]);
assertEquals(1, array[1]);
assertEquals(2, array[2]);
assertEquals(3, array[3]);
ArrayUtils.shift(array, -3);
assertEquals(3, array[0]);
assertEquals(4, array[1]);
assertEquals(1, array[2]);
assertEquals(2, array[3]);
array = new short[]{1, 2, 3, 4, 5};
ArrayUtils.shift(array, 2);
assertEquals(4, array[0]);
assertEquals(5, array[1]);
assertEquals(1, array[2]);
assertEquals(2, array[3]);
assertEquals(3, array[4]);
}
@Test
void testShiftShortArrayNull() {
final short[] array = null;
ArrayUtils.shift(array, 1);
assertNull(array);
}
@Test
void testShuffleBoolean() {
// Don't use a "small" array to reduce spurious failures.
final boolean[] array1 = { true, false, true, true, false, false, true, false, false, true, true, false, true, true, false, false, true, false, false,
true, true, false, true, true, false, false, true, false, false, true, false, true, true, false, true, true, false, false, true, false, false,
false, true, true, false, false, true, false, false, true, false, true, true, false, true, true, false, false, true, false };
final boolean[] array2 = ArrayUtils.clone(array1);
ArrayUtils.shuffle(array1);
assertFalse(Arrays.equals(array1, array2));
}
@Test
void testShuffleBooleanRandom() {
// Don't use a "small" array to reduce spurious failures.
final boolean[] array1 = { true, false, true, true, false, false, true, false, false, true, true, false, true, true, false, false, true, false, false,
true, true, false, true, true, false, false, true, false, false, true, false, true, true, false, true, true, false, false, true, false, false,
false, true, true, false, false, true, false, false, true, false, true, true, false, true, true, false, false, true, false };
final boolean[] array2 = ArrayUtils.clone(array1);
ArrayUtils.shuffle(array1, seededRandom());
assertFalse(Arrays.equals(array1, array2));
}
@Test
void testShuffleByte() {
// Don't use a "small" array, reduce spurious failures.
final byte[] array1 = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2,
3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
final byte[] array2 = ArrayUtils.clone(array1);
ArrayUtils.shuffle(array1);
assertFalse(Arrays.equals(array1, array2));
for (final byte element : array2) {
assertTrue(ArrayUtils.contains(array1, element), () -> "Element " + element + " not found");
}
}
@Test
void testShuffleByteRandom() {
// Don't use a "small" array, reduce spurious failures.
final byte[] array1 = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2,
3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
final byte[] array2 = ArrayUtils.clone(array1);
ArrayUtils.shuffle(array1, seededRandom());
assertFalse(Arrays.equals(array1, array2));
for (final byte element : array2) {
assertTrue(ArrayUtils.contains(array1, element), () -> "Element " + element + " not found");
}
}
@Test
void testShuffleChar() {
// Don't use a "small" array, reduce spurious failures.
final char[] array1 = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2,
3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
final char[] array2 = ArrayUtils.clone(array1);
ArrayUtils.shuffle(array1);
assertFalse(Arrays.equals(array1, array2));
for (final char element : array2) {
assertTrue(ArrayUtils.contains(array1, element), () -> "Element " + element + " not found");
}
}
@Test
void testShuffleCharRandom() {
// Don't use a "small" array, reduce spurious failures.
final char[] array1 = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2,
3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
final char[] array2 = ArrayUtils.clone(array1);
ArrayUtils.shuffle(array1, seededRandom());
assertFalse(Arrays.equals(array1, array2));
for (final char element : array2) {
assertTrue(ArrayUtils.contains(array1, element), () -> "Element " + element + " not found");
}
}
@Test
void testShuffleDouble() {
// Don't use a "small" array, reduce spurious failures.
final double[] array1 = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1,
2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
final double[] array2 = ArrayUtils.clone(array1);
ArrayUtils.shuffle(array1);
assertFalse(Arrays.equals(array1, array2));
for (final double element : array2) {
assertTrue(ArrayUtils.contains(array1, element), () -> "Element " + element + " not found");
}
}
@Test
void testShuffleDoubleRandom() {
// Don't use a "small" array, reduce spurious failures.
final double[] array1 = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1,
2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
final double[] array2 = ArrayUtils.clone(array1);
ArrayUtils.shuffle(array1, seededRandom());
assertFalse(Arrays.equals(array1, array2));
for (final double element : array2) {
assertTrue(ArrayUtils.contains(array1, element), () -> "Element " + element + " not found");
}
}
@Test
void testShuffleFloat() {
// Don't use a "small" array, reduce spurious failures.
final float[] array1 = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1,
2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
final float[] array2 = ArrayUtils.clone(array1);
ArrayUtils.shuffle(array1);
assertFalse(Arrays.equals(array1, array2));
for (final float element : array2) {
assertTrue(ArrayUtils.contains(array1, element), () -> "Element " + element + " not found");
}
}
@Test
void testShuffleFloatRandom() {
// Don't use a "small" array, reduce spurious failures.
final float[] array1 = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1,
2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
final float[] array2 = ArrayUtils.clone(array1);
ArrayUtils.shuffle(array1, seededRandom());
assertFalse(Arrays.equals(array1, array2));
for (final float element : array2) {
assertTrue(ArrayUtils.contains(array1, element), () -> "Element " + element + " not found");
}
}
@Test
void testShuffleInt() {
// Don't use a "small" array, reduce spurious failures.
final int[] array1 = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2,
3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
final int[] array2 = ArrayUtils.clone(array1);
ArrayUtils.shuffle(array1, seededRandom());
assertFalse(Arrays.equals(array1, array2));
for (final int element : array2) {
assertTrue(ArrayUtils.contains(array1, element), () -> "Element " + element + " not found");
}
}
@Test
void testShuffleIntRandom() {
// Don't use a "small" array, reduce spurious failures.
final int[] array1 = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2,
3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
final int[] array2 = ArrayUtils.clone(array1);
ArrayUtils.shuffle(array1);
assertFalse(Arrays.equals(array1, array2));
for (final int element : array2) {
assertTrue(ArrayUtils.contains(array1, element), () -> "Element " + element + " not found");
}
}
@Test
void testShuffleLong() {
// Don't use a "small" array, reduce spurious failures.
final long[] array1 = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2,
3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
final long[] array2 = ArrayUtils.clone(array1);
ArrayUtils.shuffle(array1);
assertFalse(Arrays.equals(array1, array2));
for (final long element : array2) {
assertTrue(ArrayUtils.contains(array1, element), () -> "Element " + element + " not found");
}
}
@Test
void testShuffleLongRandom() {
// Don't use a "small" array, reduce spurious failures.
final long[] array1 = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2,
3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
final long[] array2 = ArrayUtils.clone(array1);
ArrayUtils.shuffle(array1, seededRandom());
assertFalse(Arrays.equals(array1, array2));
for (final long element : array2) {
assertTrue(ArrayUtils.contains(array1, element), () -> "Element " + element + " not found");
}
}
@Test
void testShuffleShort() {
// Don't use a "small" array, reduce spurious failures.
final short[] array1 = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1,
2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
final short[] array2 = ArrayUtils.clone(array1);
ArrayUtils.shuffle(array1);
assertFalse(Arrays.equals(array1, array2));
for (final short element : array2) {
assertTrue(ArrayUtils.contains(array1, element), () -> "Element " + element + " not found");
}
}
@Test
void testShuffleShortRandom() {
// Don't use a "small" array, reduce spurious failures.
final short[] array1 = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1,
2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
final short[] array2 = ArrayUtils.clone(array1);
ArrayUtils.shuffle(array1, seededRandom());
assertFalse(Arrays.equals(array1, array2));
for (final short element : array2) {
assertTrue(ArrayUtils.contains(array1, element), () -> "Element " + element + " not found");
}
}
@Test
void testShuffleString() {
// Don't use a "small" array, reduce spurious failures.
final String[] array1 = { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "0", "1", "2",
"3", "4", "5", "6", "7", "8", "9", "10", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "0", "1", "2", "3", "4", "5", "6", "7", "8",
"9", "10", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10" };
final String[] array2 = ArrayUtils.clone(array1);
ArrayUtils.shuffle(array1);
assertFalse(Arrays.equals(array1, array2));
for (final String element : array2) {
assertTrue(ArrayUtils.contains(array1, element), () -> "Element " + element + " not found");
}
}
@Test
void testShuffleStringRandom() {
// Don't use a "small" array, reduce spurious failures.
final String[] array1 = { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "0", "1", "2",
"3", "4", "5", "6", "7", "8", "9", "10", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "0", "1", "2", "3", "4", "5", "6", "7", "8",
"9", "10", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10" };
final String[] array2 = ArrayUtils.clone(array1);
ArrayUtils.shuffle(array1, seededRandom());
assertFalse(Arrays.equals(array1, array2));
for (final String element : array2) {
assertTrue(ArrayUtils.contains(array1, element), () -> "Element " + element + " not found");
}
}
@Test
void testStartsWith() {
// edge cases
assertTrue(ArrayUtils.startsWith(null, null));
assertFalse(ArrayUtils.startsWith(ArrayUtils.EMPTY_BYTE_ARRAY, null));
assertFalse(ArrayUtils.startsWith(null, ArrayUtils.EMPTY_BYTE_ARRAY));
assertTrue(ArrayUtils.startsWith(ArrayUtils.EMPTY_BYTE_ARRAY, ArrayUtils.EMPTY_BYTE_ARRAY));
assertTrue(ArrayUtils.startsWith(new byte[0], new byte[0]));
// normal cases
assertTrue(ArrayUtils.startsWith(new byte[10], new byte[10]));
assertTrue(ArrayUtils.startsWith(new byte[10], new byte[9]));
assertTrue(ArrayUtils.startsWith(new byte[10], new byte[1]));
final byte[] sig = "Signature".getBytes(StandardCharsets.US_ASCII);
final byte[] data = new byte[1024];
// data is 0
assertFalse(ArrayUtils.startsWith(data, sig));
// data is 1 short for expected at the end
System.arraycopy(sig, 0, data, 0, sig.length - 1);
assertFalse(ArrayUtils.startsWith(data, sig));
// data is mimatched at the start
System.arraycopy(sig, 0, data, 0, sig.length);
data[0] = 0;
assertFalse(ArrayUtils.startsWith(data, sig));
// data is as expected
System.arraycopy(sig, 0, data, 0, sig.length);
assertTrue(ArrayUtils.startsWith(data, sig));
// expected len > data len
assertFalse(ArrayUtils.startsWith(new byte[1], new byte[2]));
}
@Test
void testSubarrayBoolean() {
final boolean[] nullArray = null;
final boolean[] array = {true, true, false, true, false, true};
final boolean[] leftSubarray = {true, true, false, true};
final boolean[] midSubarray = {true, false, true, false};
final boolean[] rightSubarray = {false, true, false, true};
assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, 0, 4)), "0 start, mid end");
assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, 0, array.length)), "0 start, length end");
assertTrue(ArrayUtils.isEquals(midSubarray, ArrayUtils.subarray(array, 1, 5)), "mid start, mid end");
assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, array.length)),
"mid start, length end");
assertNull(ArrayUtils.subarray(nullArray, 0, 3), "null input");
assertEquals(ArrayUtils.EMPTY_BOOLEAN_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_BOOLEAN_ARRAY, 1, 2),
"empty array");
assertEquals(ArrayUtils.EMPTY_BOOLEAN_ARRAY, ArrayUtils.subarray(array, 4, 2), "start > end");
assertEquals(ArrayUtils.EMPTY_BOOLEAN_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end");
assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, -2, 4)),
"start undershoot, normal end");
assertEquals(ArrayUtils.EMPTY_BOOLEAN_ARRAY, ArrayUtils.subarray(array, 33, 4), "start overshoot, any end");
assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, 33)),
"normal start, end overshoot");
assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, -2, 12)), "start undershoot, end overshoot");
// empty-return tests
assertSame(ArrayUtils.EMPTY_BOOLEAN_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_BOOLEAN_ARRAY, 1, 2),
"empty array, object test");
assertSame(ArrayUtils.EMPTY_BOOLEAN_ARRAY, ArrayUtils.subarray(array, 4, 1), "start > end, object test");
assertSame(ArrayUtils.EMPTY_BOOLEAN_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end, object test");
assertSame(ArrayUtils.EMPTY_BOOLEAN_ARRAY, ArrayUtils.subarray(array, 8733, 4),
"start overshoot, any end, object test");
// array type tests
assertSame(boolean.class, ArrayUtils.subarray(array, 2, 4).getClass().getComponentType(), "boolean type");
}
@Test
void testSubarrayByte() {
final byte[] nullArray = null;
final byte[] array = { 10, 11, 12, 13, 14, 15 };
final byte[] leftSubarray = { 10, 11, 12, 13 };
final byte[] midSubarray = { 11, 12, 13, 14 };
final byte[] rightSubarray = { 12, 13, 14, 15 };
assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, 0, 4)), "0 start, mid end");
assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, 0, array.length)), "0 start, length end");
assertTrue(ArrayUtils.isEquals(midSubarray, ArrayUtils.subarray(array, 1, 5)), "mid start, mid end");
assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, array.length)), "mid start, length end");
assertNull(ArrayUtils.subarray(nullArray, 0, 3), "null input");
assertEquals(ArrayUtils.EMPTY_BYTE_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_BYTE_ARRAY, 1, 2), "empty array");
assertEquals(ArrayUtils.EMPTY_BYTE_ARRAY, ArrayUtils.subarray(array, 4, 2), "start > end");
assertEquals(ArrayUtils.EMPTY_BYTE_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end");
assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, -2, 4)), "start undershoot, normal end");
assertEquals(ArrayUtils.EMPTY_BYTE_ARRAY, ArrayUtils.subarray(array, 33, 4), "start overshoot, any end");
assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, 33)), "normal start, end overshoot");
assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, -2, 12)), "start undershoot, end overshoot");
// empty-return tests
assertSame(ArrayUtils.EMPTY_BYTE_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_BYTE_ARRAY, 1, 2), "empty array, object test");
assertSame(ArrayUtils.EMPTY_BYTE_ARRAY, ArrayUtils.subarray(array, 4, 1), "start > end, object test");
assertSame(ArrayUtils.EMPTY_BYTE_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end, object test");
assertSame(ArrayUtils.EMPTY_BYTE_ARRAY, ArrayUtils.subarray(array, 8733, 4), "start overshoot, any end, object test");
// array type tests
assertSame(byte.class, ArrayUtils.subarray(array, 2, 4).getClass().getComponentType(), "byte type");
}
@Test
void testSubarrayDouble() {
final double[] nullArray = null;
final double[] array = { 10.123, 11.234, 12.345, 13.456, 14.567, 15.678 };
final double[] leftSubarray = { 10.123, 11.234, 12.345, 13.456 };
final double[] midSubarray = { 11.234, 12.345, 13.456, 14.567 };
final double[] rightSubarray = { 12.345, 13.456, 14.567, 15.678 };
assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, 0, 4)), "0 start, mid end");
assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, 0, array.length)), "0 start, length end");
assertTrue(ArrayUtils.isEquals(midSubarray, ArrayUtils.subarray(array, 1, 5)), "mid start, mid end");
assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, array.length)), "mid start, length end");
assertNull(ArrayUtils.subarray(nullArray, 0, 3), "null input");
assertEquals(ArrayUtils.EMPTY_DOUBLE_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_DOUBLE_ARRAY, 1, 2), "empty array");
assertEquals(ArrayUtils.EMPTY_DOUBLE_ARRAY, ArrayUtils.subarray(array, 4, 2), "start > end");
assertEquals(ArrayUtils.EMPTY_DOUBLE_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end");
assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, -2, 4)), "start undershoot, normal end");
assertEquals(ArrayUtils.EMPTY_DOUBLE_ARRAY, ArrayUtils.subarray(array, 33, 4), "start overshoot, any end");
assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, 33)), "normal start, end overshoot");
assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, -2, 12)), "start undershoot, end overshoot");
// empty-return tests
assertSame(ArrayUtils.EMPTY_DOUBLE_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_DOUBLE_ARRAY, 1, 2), "empty array, object test");
assertSame(ArrayUtils.EMPTY_DOUBLE_ARRAY, ArrayUtils.subarray(array, 4, 1), "start > end, object test");
assertSame(ArrayUtils.EMPTY_DOUBLE_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end, object test");
assertSame(ArrayUtils.EMPTY_DOUBLE_ARRAY, ArrayUtils.subarray(array, 8733, 4), "start overshoot, any end, object test");
// array type tests
assertSame(double.class, ArrayUtils.subarray(array, 2, 4).getClass().getComponentType(), "double type");
}
@Test
void testSubarrayFloat() {
final float[] nullArray = null;
final float[] array = { 10, 11, 12, 13, 14, 15 };
final float[] leftSubarray = { 10, 11, 12, 13 };
final float[] midSubarray = { 11, 12, 13, 14 };
final float[] rightSubarray = { 12, 13, 14, 15 };
assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, 0, 4)), "0 start, mid end");
assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, 0, array.length)), "0 start, length end");
assertTrue(ArrayUtils.isEquals(midSubarray, ArrayUtils.subarray(array, 1, 5)), "mid start, mid end");
assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, array.length)), "mid start, length end");
assertNull(ArrayUtils.subarray(nullArray, 0, 3), "null input");
assertEquals(ArrayUtils.EMPTY_FLOAT_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_FLOAT_ARRAY, 1, 2), "empty array");
assertEquals(ArrayUtils.EMPTY_FLOAT_ARRAY, ArrayUtils.subarray(array, 4, 2), "start > end");
assertEquals(ArrayUtils.EMPTY_FLOAT_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end");
assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, -2, 4)), "start undershoot, normal end");
assertEquals(ArrayUtils.EMPTY_FLOAT_ARRAY, ArrayUtils.subarray(array, 33, 4), "start overshoot, any end");
assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, 33)), "normal start, end overshoot");
assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, -2, 12)), "start undershoot, end overshoot");
// empty-return tests
assertSame(ArrayUtils.EMPTY_FLOAT_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_FLOAT_ARRAY, 1, 2), "empty array, object test");
assertSame(ArrayUtils.EMPTY_FLOAT_ARRAY, ArrayUtils.subarray(array, 4, 1), "start > end, object test");
assertSame(ArrayUtils.EMPTY_FLOAT_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end, object test");
assertSame(ArrayUtils.EMPTY_FLOAT_ARRAY, ArrayUtils.subarray(array, 8733, 4), "start overshoot, any end, object test");
// array type tests
assertSame(float.class, ArrayUtils.subarray(array, 2, 4).getClass().getComponentType(), "float type");
}
@Test
void testSubarrayInt() {
final int[] nullArray = null;
final int[] array = { 10, 11, 12, 13, 14, 15 };
final int[] leftSubarray = { 10, 11, 12, 13 };
final int[] midSubarray = { 11, 12, 13, 14 };
final int[] rightSubarray = { 12, 13, 14, 15 };
assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, 0, 4)), "0 start, mid end");
assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, 0, array.length)), "0 start, length end");
assertTrue(ArrayUtils.isEquals(midSubarray, ArrayUtils.subarray(array, 1, 5)), "mid start, mid end");
assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, array.length)), "mid start, length end");
assertNull(ArrayUtils.subarray(nullArray, 0, 3), "null input");
assertEquals(ArrayUtils.EMPTY_INT_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_INT_ARRAY, 1, 2), "empty array");
assertEquals(ArrayUtils.EMPTY_INT_ARRAY, ArrayUtils.subarray(array, 4, 2), "start > end");
assertEquals(ArrayUtils.EMPTY_INT_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end");
assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, -2, 4)), "start undershoot, normal end");
assertEquals(ArrayUtils.EMPTY_INT_ARRAY, ArrayUtils.subarray(array, 33, 4), "start overshoot, any end");
assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, 33)), "normal start, end overshoot");
assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, -2, 12)), "start undershoot, end overshoot");
// empty-return tests
assertSame(ArrayUtils.EMPTY_INT_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_INT_ARRAY, 1, 2), "empty array, object test");
assertSame(ArrayUtils.EMPTY_INT_ARRAY, ArrayUtils.subarray(array, 4, 1), "start > end, object test");
assertSame(ArrayUtils.EMPTY_INT_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end, object test");
assertSame(ArrayUtils.EMPTY_INT_ARRAY, ArrayUtils.subarray(array, 8733, 4), "start overshoot, any end, object test");
// array type tests
assertSame(int.class, ArrayUtils.subarray(array, 2, 4).getClass().getComponentType(), "int type");
}
@Test
void testSubarrayLong() {
final long[] nullArray = null;
final long[] array = {999910, 999911, 999912, 999913, 999914, 999915};
final long[] leftSubarray = {999910, 999911, 999912, 999913};
final long[] midSubarray = {999911, 999912, 999913, 999914};
final long[] rightSubarray = {999912, 999913, 999914, 999915};
assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, 0, 4)), "0 start, mid end");
assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, 0, array.length)), "0 start, length end");
assertTrue(ArrayUtils.isEquals(midSubarray, ArrayUtils.subarray(array, 1, 5)), "mid start, mid end");
assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, array.length)),
"mid start, length end");
assertNull(ArrayUtils.subarray(nullArray, 0, 3), "null input");
assertEquals(ArrayUtils.EMPTY_LONG_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_LONG_ARRAY, 1, 2),
"empty array");
assertEquals(ArrayUtils.EMPTY_LONG_ARRAY, ArrayUtils.subarray(array, 4, 2), "start > end");
assertEquals(ArrayUtils.EMPTY_LONG_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end");
assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, -2, 4)),
"start undershoot, normal end");
assertEquals(ArrayUtils.EMPTY_LONG_ARRAY, ArrayUtils.subarray(array, 33, 4), "start overshoot, any end");
assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, 33)),
"normal start, end overshoot");
assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, -2, 12)), "start undershoot, end overshoot");
// empty-return tests
assertSame(ArrayUtils.EMPTY_LONG_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_LONG_ARRAY, 1, 2),
"empty array, object test");
assertSame(ArrayUtils.EMPTY_LONG_ARRAY, ArrayUtils.subarray(array, 4, 1), "start > end, object test");
assertSame(ArrayUtils.EMPTY_LONG_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end, object test");
assertSame(ArrayUtils.EMPTY_LONG_ARRAY, ArrayUtils.subarray(array, 8733, 4),
"start overshoot, any end, object test");
// array type tests
assertSame(long.class, ArrayUtils.subarray(array, 2, 4).getClass().getComponentType(), "long type");
}
@Test
void testSubarrayObject() {
final Object[] nullArray = null;
final Object[] objectArray = {"a", "b", "c", "d", "e", "f"};
assertEquals("abcd", StringUtils.join(ArrayUtils.subarray(objectArray, 0, 4)), "0 start, mid end");
assertEquals("abcdef", StringUtils.join(ArrayUtils.subarray(objectArray, 0, objectArray.length)),
"0 start, length end");
assertEquals("bcd", StringUtils.join(ArrayUtils.subarray(objectArray, 1, 4)), "mid start, mid end");
assertEquals("bcdef", StringUtils.join(ArrayUtils.subarray(objectArray, 1, objectArray.length)),
"mid start, length end");
assertNull(ArrayUtils.subarray(nullArray, 0, 3), "null input");
assertEquals("", StringUtils.join(ArrayUtils.subarray(ArrayUtils.EMPTY_OBJECT_ARRAY, 1, 2)), "empty array");
assertEquals("", StringUtils.join(ArrayUtils.subarray(objectArray, 4, 2)), "start > end");
assertEquals("", StringUtils.join(ArrayUtils.subarray(objectArray, 3, 3)), "start == end");
assertEquals("abcd", StringUtils.join(ArrayUtils.subarray(objectArray, -2, 4)), "start undershoot, normal end");
assertEquals("", StringUtils.join(ArrayUtils.subarray(objectArray, 33, 4)), "start overshoot, any end");
assertEquals("cdef", StringUtils.join(ArrayUtils.subarray(objectArray, 2, 33)), "normal start, end overshoot");
assertEquals("abcdef", StringUtils.join(ArrayUtils.subarray(objectArray, -2, 12)),
"start undershoot, end overshoot");
// array type tests
final Date[] dateArray = {new java.sql.Date(new Date().getTime()),
new Date(), new Date(), new Date(), new Date()};
assertSame(Object.class, ArrayUtils.subarray(objectArray, 2, 4).getClass().getComponentType(), "Object type");
assertSame(Date.class, ArrayUtils.subarray(dateArray, 1, 4).getClass().getComponentType(),
"java.util.Date type");
assertNotSame(java.sql.Date.class, ArrayUtils.subarray(dateArray, 1, 4).getClass().getComponentType(),
"java.sql.Date type");
assertThrows(ClassCastException.class,
() -> java.sql.Date[].class.cast(ArrayUtils.subarray(dateArray, 1, 3)),
"Invalid downcast");
}
@Test
void testSubarrayShort() {
final short[] nullArray = null;
final short[] array = {10, 11, 12, 13, 14, 15};
final short[] leftSubarray = {10, 11, 12, 13};
final short[] midSubarray = {11, 12, 13, 14};
final short[] rightSubarray = {12, 13, 14, 15};
assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, 0, 4)), "0 start, mid end");
assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, 0, array.length)), "0 start, length end");
assertTrue(ArrayUtils.isEquals(midSubarray, ArrayUtils.subarray(array, 1, 5)), "mid start, mid end");
assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, array.length)),
"mid start, length end");
assertNull(ArrayUtils.subarray(nullArray, 0, 3), "null input");
assertEquals(ArrayUtils.EMPTY_SHORT_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_SHORT_ARRAY, 1, 2),
"empty array");
assertEquals(ArrayUtils.EMPTY_SHORT_ARRAY, ArrayUtils.subarray(array, 4, 2), "start > end");
assertEquals(ArrayUtils.EMPTY_SHORT_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end");
assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, -2, 4)),
"start undershoot, normal end");
assertEquals(ArrayUtils.EMPTY_SHORT_ARRAY, ArrayUtils.subarray(array, 33, 4), "start overshoot, any end");
assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, 33)),
"normal start, end overshoot");
assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, -2, 12)), "start undershoot, end overshoot");
// empty-return tests
assertSame(ArrayUtils.EMPTY_SHORT_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_SHORT_ARRAY, 1, 2),
"empty array, object test");
assertSame(ArrayUtils.EMPTY_SHORT_ARRAY, ArrayUtils.subarray(array, 4, 1), "start > end, object test");
assertSame(ArrayUtils.EMPTY_SHORT_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end, object test");
assertSame(ArrayUtils.EMPTY_SHORT_ARRAY, ArrayUtils.subarray(array, 8733, 4),
"start overshoot, any end, object test");
// array type tests
assertSame(short.class, ArrayUtils.subarray(array, 2, 4).getClass().getComponentType(), "short type");
}
@Test
void testSubarrChar() {
final char[] nullArray = null;
final char[] array = { 'a', 'b', 'c', 'd', 'e', 'f' };
final char[] leftSubarray = { 'a', 'b', 'c', 'd' };
final char[] midSubarray = { 'b', 'c', 'd', 'e' };
final char[] rightSubarray = { 'c', 'd', 'e', 'f' };
assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, 0, 4)), "0 start, mid end");
assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, 0, array.length)), "0 start, length end");
assertTrue(ArrayUtils.isEquals(midSubarray, ArrayUtils.subarray(array, 1, 5)), "mid start, mid end");
assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, array.length)), "mid start, length end");
assertNull(ArrayUtils.subarray(nullArray, 0, 3), "null input");
assertEquals(ArrayUtils.EMPTY_CHAR_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_CHAR_ARRAY, 1, 2), "empty array");
assertEquals(ArrayUtils.EMPTY_CHAR_ARRAY, ArrayUtils.subarray(array, 4, 2), "start > end");
assertEquals(ArrayUtils.EMPTY_CHAR_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end");
assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, -2, 4)), "start undershoot, normal end");
assertEquals(ArrayUtils.EMPTY_CHAR_ARRAY, ArrayUtils.subarray(array, 33, 4), "start overshoot, any end");
assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, 33)), "normal start, end overshoot");
assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, -2, 12)), "start undershoot, end overshoot");
// empty-return tests
assertSame(ArrayUtils.EMPTY_CHAR_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_CHAR_ARRAY, 1, 2), "empty array, object test");
assertSame(ArrayUtils.EMPTY_CHAR_ARRAY, ArrayUtils.subarray(array, 4, 1), "start > end, object test");
assertSame(ArrayUtils.EMPTY_CHAR_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end, object test");
assertSame(ArrayUtils.EMPTY_CHAR_ARRAY, ArrayUtils.subarray(array, 8733, 4), "start overshoot, any end, object test");
// array type tests
assertSame(char.class, ArrayUtils.subarray(array, 2, 4).getClass().getComponentType(), "char type");
}
@Test
void testSwapBoolean() {
final boolean[] array = { true, false, false };
ArrayUtils.swap(array, 0, 2);
assertFalse(array[0]);
assertFalse(array[1]);
assertTrue(array[2]);
}
@Test
void testSwapBooleanRange() {
// edge cases where nothing happens
ArrayUtils.swap((boolean[]) null, 0, 2, 1);
ArrayUtils.swap(new boolean[0], 0, 2, 1);
final boolean[] array3a = {true, false, true};
final boolean[] array3b = array3a.clone();
// (1) offset1 >= array.length
ArrayUtils.swap(array3b, array3b.length, 2, 1);
assertArrayEquals(array3a, array3b);
// (2) offset2 >= array.length
ArrayUtils.swap(array3b, 0, array3b.length, 1);
assertArrayEquals(array3a, array3b);
// tests
boolean[] array = { false, false, true, true };
ArrayUtils.swap(array, 0, 2, 2);
assertTrue(array[0]);
assertTrue(array[1]);
assertFalse(array[2]);
assertFalse(array[3]);
array = new boolean[] { false, true, false };
ArrayUtils.swap(array, 0, 3);
assertFalse(array[0]);
assertTrue(array[1]);
assertFalse(array[2]);
array = new boolean[] { true, true, false };
ArrayUtils.swap(array, 0, 2, 2);
assertFalse(array[0]);
assertTrue(array[1]);
assertTrue(array[2]);
array = new boolean[] { true, true, false };
ArrayUtils.swap(array, -1, 2, 2);
assertFalse(array[0]);
assertTrue(array[1]);
assertTrue(array[2]);
array = new boolean[] { true, true, false };
ArrayUtils.swap(array, 0, -1, 2);
assertTrue(array[0]);
assertTrue(array[1]);
assertFalse(array[2]);
array = new boolean[] { true, true, false };
ArrayUtils.swap(array, -1, -1, 2);
assertTrue(array[0]);
assertTrue(array[1]);
assertFalse(array[2]);
}
@Test
void testSwapByte() {
final byte[] array = { 1, 2, 3 };
ArrayUtils.swap(array, 0, 2);
assertEquals(3, array[0]);
assertEquals(2, array[1]);
assertEquals(1, array[2]);
}
@Test
void testSwapByteRange() {
// edge cases where nothing happens
ArrayUtils.swap((byte[]) null, 0, 2, 1);
ArrayUtils.swap(new byte[0], 0, 2, 1);
final byte[] array3a = {1, 0, 1};
final byte[] array3b = array3a.clone();
// (1) offset1 >= array.length
ArrayUtils.swap(array3b, array3b.length, 2, 1);
assertArrayEquals(array3a, array3b);
// (2) offset2 >= array.length
ArrayUtils.swap(array3b, 0, array3b.length, 1);
assertArrayEquals(array3a, array3b);
// tests
byte[] array = { 1, 2, 3, 4 };
ArrayUtils.swap(array, 0, 2, 2);
assertEquals(3, array[0]);
assertEquals(4, array[1]);
assertEquals(1, array[2]);
assertEquals(2, array[3]);
array = new byte[] { 1, 2, 3 };
ArrayUtils.swap(array, 0, 3);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
assertEquals(3, array[2]);
array = new byte[] { 1, 2, 3 };
ArrayUtils.swap(array, 0, 2, 2);
assertEquals(3, array[0]);
assertEquals(2, array[1]);
assertEquals(1, array[2]);
array = new byte[] { 1, 2, 3 };
ArrayUtils.swap(array, -1, 2, 2);
assertEquals(3, array[0]);
assertEquals(2, array[1]);
assertEquals(1, array[2]);
array = new byte[] { 1, 2, 3 };
ArrayUtils.swap(array, 0, -1, 2);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
assertEquals(3, array[2]);
array = new byte[] { 1, 2, 3 };
ArrayUtils.swap(array, -1, -1, 2);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
assertEquals(3, array[2]);
}
@Test
void testSwapChar() {
char[] array = { 1, 2, 3 };
ArrayUtils.swap(array, 0, 2);
assertArrayEquals(new char[] { 3, 2, 1 }, array);
array = new char[] { 1, 2, 3 };
ArrayUtils.swap(array, 0, 0);
assertArrayEquals(new char[] { 1, 2, 3 }, array);
array = new char[] { 1, 2, 3 };
ArrayUtils.swap(array, 1, 0);
assertArrayEquals(new char[] { 2, 1, 3 }, array);
}
@Test
void testSwapCharRange() {
// edge cases where nothing happens
ArrayUtils.swap((char[]) null, 0, 2, 1);
ArrayUtils.swap(new char[0], 0, 2, 1);
final char[] array3a = {1, 0, 1};
final char[] array3b = array3a.clone();
// (1) offset1 >= array.length
ArrayUtils.swap(array3b, array3b.length, 2, 1);
assertArrayEquals(array3a, array3b);
// (2) offset2 >= array.length
ArrayUtils.swap(array3b, 0, array3b.length, 1);
assertArrayEquals(array3a, array3b);
// tests
char[] array = { 1, 2, 3, 4 };
ArrayUtils.swap(array, 0, 2, 2);
assertEquals(3, array[0]);
assertEquals(4, array[1]);
assertEquals(1, array[2]);
assertEquals(2, array[3]);
array = new char[] { 1, 2, 3 };
ArrayUtils.swap(array, 0, 3);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
assertEquals(3, array[2]);
array = new char[] { 1, 2, 3 };
ArrayUtils.swap(array, 0, 2, 2);
assertEquals(3, array[0]);
assertEquals(2, array[1]);
assertEquals(1, array[2]);
array = new char[] { 1, 2, 3 };
ArrayUtils.swap(array, -1, 2, 2);
assertEquals(3, array[0]);
assertEquals(2, array[1]);
assertEquals(1, array[2]);
array = new char[] { 1, 2, 3 };
ArrayUtils.swap(array, 0, -1, 2);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
assertEquals(3, array[2]);
array = new char[] { 1, 2, 3 };
ArrayUtils.swap(array, -1, -1, 2);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
assertEquals(3, array[2]);
}
@Test
void testSwapDouble() {
final double[] array = { 1, 2, 3 };
ArrayUtils.swap(array, 0, 2);
assertEquals(3, array[0]);
assertEquals(2, array[1]);
assertEquals(1, array[2]);
}
@Test
void testSwapDoubleRange() {
// edge cases where nothing happens
ArrayUtils.swap((double[]) null, 0, 2, 1);
ArrayUtils.swap(new double[0], 0, 2, 1);
final double[] array3a = {1, 0, 1};
final double[] array3b = array3a.clone();
// (1) offset1 >= array.length
ArrayUtils.swap(array3b, array3b.length, 2, 1);
assertArrayEquals(array3a, array3b);
// (2) offset2 >= array.length
ArrayUtils.swap(array3b, 0, array3b.length, 1);
assertArrayEquals(array3a, array3b);
// tests
double[] array = { 1, 2, 3, 4 };
ArrayUtils.swap(array, 0, 2, 2);
assertEquals(3, array[0]);
assertEquals(4, array[1]);
assertEquals(1, array[2]);
assertEquals(2, array[3]);
array = new double[] { 1, 2, 3 };
ArrayUtils.swap(array, 0, 3);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
assertEquals(3, array[2]);
array = new double[] { 1, 2, 3 };
ArrayUtils.swap(array, 0, 2, 2);
assertEquals(3, array[0]);
assertEquals(2, array[1]);
assertEquals(1, array[2]);
array = new double[] { 1, 2, 3 };
ArrayUtils.swap(array, -1, 2, 2);
assertEquals(3, array[0]);
assertEquals(2, array[1]);
assertEquals(1, array[2]);
array = new double[] { 1, 2, 3 };
ArrayUtils.swap(array, 0, -1, 2);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
assertEquals(3, array[2]);
array = new double[] { 1, 2, 3 };
ArrayUtils.swap(array, -1, -1, 2);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
assertEquals(3, array[2]);
}
@Test
void testSwapEmptyBooleanArray() {
final boolean[] array = {};
ArrayUtils.swap(array, 0, 2);
assertEquals(0, array.length);
}
@Test
void testSwapEmptyByteArray() {
final byte[] array = {};
ArrayUtils.swap(array, 0, 2);
assertEquals(0, array.length);
}
@Test
void testSwapEmptyCharArray() {
final char[] array = {};
ArrayUtils.swap(array, 0, 2);
assertEquals(0, array.length);
}
@Test
void testSwapEmptyDoubleArray() {
final double[] array = {};
ArrayUtils.swap(array, 0, 2);
assertEquals(0, array.length);
}
@Test
void testSwapEmptyFloatArray() {
final float[] array = {};
ArrayUtils.swap(array, 0, 2);
assertEquals(0, array.length);
}
@Test
void testSwapEmptyIntArray() {
final int[] array = {};
ArrayUtils.swap(array, 0, 2);
assertEquals(0, array.length);
}
@Test
void testSwapEmptyLongArray() {
final long[] array = {};
ArrayUtils.swap(array, 0, 2);
assertEquals(0, array.length);
}
@Test
void testSwapEmptyObjectArray() {
final String[] array = {};
ArrayUtils.swap(array, 0, 2);
assertEquals(0, array.length);
}
@Test
void testSwapEmptyShortArray() {
final short[] array = {};
ArrayUtils.swap(array, 0, 2);
assertEquals(0, array.length);
}
@Test
void testSwapFloat() {
final float[] array = { 1, 2, 3 };
ArrayUtils.swap(array, 0, 2);
assertEquals(3, array[0]);
assertEquals(2, array[1]);
assertEquals(1, array[2]);
}
@Test
void testSwapFloatRange() {
// edge cases where nothing happens
ArrayUtils.swap((float[]) null, 0, 2, 1);
ArrayUtils.swap(new float[0], 0, 2, 1);
final float[] array3a = {1, 0, 1};
final float[] array3b = array3a.clone();
// (1) offset1 >= array.length
ArrayUtils.swap(array3b, array3b.length, 2, 1);
assertArrayEquals(array3a, array3b);
// (2) offset2 >= array.length
ArrayUtils.swap(array3b, 0, array3b.length, 1);
assertArrayEquals(array3a, array3b);
// tests
float[] array = { 1, 2, 3, 4 };
ArrayUtils.swap(array, 0, 2, 2);
assertEquals(3, array[0]);
assertEquals(4, array[1]);
assertEquals(1, array[2]);
assertEquals(2, array[3]);
array = new float[] { 1, 2, 3 };
ArrayUtils.swap(array, 0, 3);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
assertEquals(3, array[2]);
array = new float[] { 1, 2, 3 };
ArrayUtils.swap(array, 0, 2, 2);
assertEquals(3, array[0]);
assertEquals(2, array[1]);
assertEquals(1, array[2]);
array = new float[] { 1, 2, 3 };
ArrayUtils.swap(array, -1, 2, 2);
assertEquals(3, array[0]);
assertEquals(2, array[1]);
assertEquals(1, array[2]);
array = new float[] { 1, 2, 3 };
ArrayUtils.swap(array, 0, -1, 2);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
assertEquals(3, array[2]);
array = new float[] { 1, 2, 3 };
ArrayUtils.swap(array, -1, -1, 2);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
assertEquals(3, array[2]);
}
@Test
void testSwapInt() {
final int[] array = { 1, 2, 3 };
ArrayUtils.swap(array, 0, 2);
assertEquals(3, array[0]);
assertEquals(2, array[1]);
assertEquals(1, array[2]);
}
@Test
void testSwapIntExchangedOffsets() {
int[] array;
array = new int[] { 1, 2, 3 };
ArrayUtils.swap(array, 0, 1, 2);
assertArrayEquals(new int[] { 2, 3, 1 }, array);
array = new int[] { 1, 2, 3 };
ArrayUtils.swap(array, 1, 0, 2);
assertArrayEquals(new int[] { 2, 3, 1 }, array);
}
@Test
void testSwapIntRange() {
// edge cases where nothing happens
ArrayUtils.swap((int[]) null, 0, 2, 1);
ArrayUtils.swap(new int[0], 0, 2, 1);
final int[] array3a = {1, 0, 1};
final int[] array3b = array3a.clone();
// (1) offset1 >= array.length
ArrayUtils.swap(array3b, array3b.length, 2, 1);
assertArrayEquals(array3a, array3b);
// (2) offset2 >= array.length
ArrayUtils.swap(array3b, 0, array3b.length, 1);
assertArrayEquals(array3a, array3b);
// tests
int[] array = { 1, 2, 3, 4 };
ArrayUtils.swap(array, 0, 2, 2);
assertEquals(3, array[0]);
assertEquals(4, array[1]);
assertEquals(1, array[2]);
assertEquals(2, array[3]);
array = new int[] { 1, 2, 3 };
ArrayUtils.swap(array, 3, 0);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
assertEquals(3, array[2]);
array = new int[] { 1, 2, 3 };
ArrayUtils.swap(array, 0, 2, 2);
assertEquals(3, array[0]);
assertEquals(2, array[1]);
assertEquals(1, array[2]);
array = new int[] { 1, 2, 3 };
ArrayUtils.swap(array, -1, 2, 2);
assertEquals(3, array[0]);
assertEquals(2, array[1]);
assertEquals(1, array[2]);
array = new int[] { 1, 2, 3 };
ArrayUtils.swap(array, 0, -1, 2);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
assertEquals(3, array[2]);
array = new int[] { 1, 2, 3 };
ArrayUtils.swap(array, -1, -1, 2);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
assertEquals(3, array[2]);
}
@Test
void testSwapLong() {
final long[] array = { 1, 2, 3 };
ArrayUtils.swap(array, 0, 2);
assertEquals(3, array[0]);
assertEquals(2, array[1]);
assertEquals(1, array[2]);
}
@Test
void testSwapLongRange() {
// edge cases where nothing happens
ArrayUtils.swap((long[]) null, 0, 2, 1);
ArrayUtils.swap(new long[0], 0, 2, 1);
final long[] array3a = {1, 0, 1};
final long[] array3b = array3a.clone();
// (1) offset1 >= array.length
ArrayUtils.swap(array3b, array3b.length, 2, 1);
assertArrayEquals(array3a, array3b);
// (2) offset2 >= array.length
ArrayUtils.swap(array3b, 0, array3b.length, 1);
assertArrayEquals(array3a, array3b);
// tests
long[] array = { 1, 2, 3, 4 };
ArrayUtils.swap(array, 0, 2, 2);
assertEquals(3, array[0]);
assertEquals(4, array[1]);
assertEquals(1, array[2]);
assertEquals(2, array[3]);
array = new long[] { 1, 2, 3 };
ArrayUtils.swap(array, 0, 3);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
assertEquals(3, array[2]);
array = new long[] { 1, 2, 3 };
ArrayUtils.swap(array, 0, 2, 2);
assertEquals(3, array[0]);
assertEquals(2, array[1]);
assertEquals(1, array[2]);
array = new long[] { 1, 2, 3 };
ArrayUtils.swap(array, -1, 2, 2);
assertEquals(3, array[0]);
assertEquals(2, array[1]);
assertEquals(1, array[2]);
array = new long[] { 1, 2, 3 };
ArrayUtils.swap(array, 0, -1, 2);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
assertEquals(3, array[2]);
array = new long[] { 1, 2, 3 };
ArrayUtils.swap(array, -1, -1, 2);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
assertEquals(3, array[2]);
}
@Test
void testSwapNullBooleanArray() {
final boolean[] array = null;
ArrayUtils.swap(array, 0, 2);
assertNull(array);
}
@Test
void testSwapNullByteArray() {
final byte[] array = null;
ArrayUtils.swap(array, 0, 2);
assertNull(array);
}
@Test
void testSwapNullCharArray() {
final char[] array = null;
ArrayUtils.swap(array, 0, 2);
assertNull(array);
}
@Test
void testSwapNullDoubleArray() {
final double[] array = null;
ArrayUtils.swap(array, 0, 2);
assertNull(array);
}
@Test
void testSwapNullFloatArray() {
final float[] array = null;
ArrayUtils.swap(array, 0, 2);
assertNull(array);
}
@Test
void testSwapNullIntArray() {
final int[] array = null;
ArrayUtils.swap(array, 0, 2);
assertNull(array);
}
@Test
void testSwapNullLongArray() {
final long[] array = null;
ArrayUtils.swap(array, 0, 2);
assertNull(array);
}
@Test
void testSwapNullObjectArray() {
final String[] array = null;
ArrayUtils.swap(array, 0, 2);
assertNull(array);
}
@Test
void testSwapNullShortArray() {
final short[] array = null;
ArrayUtils.swap(array, 0, 2);
assertNull(array);
}
@Test
void testSwapObject() {
final String[] array = { "1", "2", "3" };
ArrayUtils.swap(array, 0, 2);
assertEquals("3", array[0]);
assertEquals("2", array[1]);
assertEquals("1", array[2]);
}
@Test
void testSwapObjectRange() {
// edge cases where nothing happens
ArrayUtils.swap((Object[]) null, 0, 2, 1);
ArrayUtils.swap(new Object[0], 0, 2, 1);
final Object[] array3a = {1, 0, 1};
final Object[] array3b = array3a.clone();
// (1) offset1 >= array.length
ArrayUtils.swap(array3b, array3b.length, 2, 1);
assertArrayEquals(array3a, array3b);
// (2) offset2 >= array.length
ArrayUtils.swap(array3b, 0, array3b.length, 1);
assertArrayEquals(array3a, array3b);
// tests
String[] array = { "1", "2", "3", "4" };
ArrayUtils.swap(array, 0, 2, 2);
assertEquals("3", array[0]);
assertEquals("4", array[1]);
assertEquals("1", array[2]);
assertEquals("2", array[3]);
array = new String[] { "1", "2", "3", "4" };
ArrayUtils.swap(array, -1, 2, 3);
assertEquals("3", array[0]);
assertEquals("4", array[1]);
assertEquals("1", array[2]);
assertEquals("2", array[3]);
array = new String[] { "1", "2", "3", "4", "5" };
ArrayUtils.swap(array, -3, 2, 3);
assertEquals("3", array[0]);
assertEquals("4", array[1]);
assertEquals("5", array[2]);
assertEquals("2", array[3]);
assertEquals("1", array[4]);
array = new String[] { "1", "2", "3", "4", "5" };
ArrayUtils.swap(array, 2, -2, 3);
assertEquals("3", array[0]);
assertEquals("4", array[1]);
assertEquals("5", array[2]);
assertEquals("2", array[3]);
assertEquals("1", array[4]);
array = new String[0];
ArrayUtils.swap(array, 0, 2, 2);
assertEquals(0, array.length);
array = null;
ArrayUtils.swap(array, 0, 2, 2);
assertNull(array);
}
@Test
void testSwapShort() {
final short[] array = { 1, 2, 3 };
ArrayUtils.swap(array, 0, 2);
assertEquals(3, array[0]);
assertEquals(2, array[1]);
assertEquals(1, array[2]);
}
@Test
void testSwapShortRange() {
// edge cases where nothing happens
ArrayUtils.swap((short[]) null, 0, 2, 1);
ArrayUtils.swap(new short[0], 0, 2, 1);
final short[] array3a = {1, 0, 1};
final short[] array3b = array3a.clone();
// (1) offset1 >= array.length
ArrayUtils.swap(array3b, array3b.length, 2, 1);
assertArrayEquals(array3a, array3b);
// (2) offset2 >= array.length
ArrayUtils.swap(array3b, 0, array3b.length, 1);
assertArrayEquals(array3a, array3b);
// tests
short[] array = { 1, 2, 3, 4 };
ArrayUtils.swap(array, 0, 2, 2);
assertEquals(3, array[0]);
assertEquals(4, array[1]);
assertEquals(1, array[2]);
assertEquals(2, array[3]);
array = new short[] { 1, 2, 3 };
ArrayUtils.swap(array, 3, 0);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
assertEquals(3, array[2]);
array = new short[] { 1, 2, 3 };
ArrayUtils.swap(array, 0, 2, 2);
assertEquals(3, array[0]);
assertEquals(2, array[1]);
assertEquals(1, array[2]);
array = new short[] { 1, 2, 3 };
ArrayUtils.swap(array, -1, 2, 2);
assertEquals(3, array[0]);
assertEquals(2, array[1]);
assertEquals(1, array[2]);
array = new short[] { 1, 2, 3 };
ArrayUtils.swap(array, 0, -1, 2);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
assertEquals(3, array[2]);
array = new short[] { 1, 2, 3 };
ArrayUtils.swap(array, -1, -1, 2);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
assertEquals(3, array[2]);
}
@Test
void testTextIndexesOfInt() {
int[] array = null;
final BitSet emptySet = new BitSet();
final BitSet testSet = new BitSet();
assertEquals(emptySet, ArrayUtils.indexesOf(array, 0));
array = new int[] { 0, 1, 2, 3, 0 };
testSet.set(0);
testSet.set(4);
assertEquals(testSet, ArrayUtils.indexesOf(array, 0));
testSet.clear();
testSet.set(1);
assertEquals(testSet, ArrayUtils.indexesOf(array, 1));
testSet.clear();
testSet.set(2);
assertEquals(testSet, ArrayUtils.indexesOf(array, 2));
testSet.clear();
testSet.set(3);
assertEquals(testSet, ArrayUtils.indexesOf(array, 3));
assertEquals(emptySet, ArrayUtils.indexesOf(array, 99));
}
@Test
void testToMap() {
Map<?, ?> map = ArrayUtils.toMap(new String[][] { { "foo", "bar" }, { "hello", "world" } });
assertEquals("bar", map.get("foo"));
assertEquals("world", map.get("hello"));
assertNull(ArrayUtils.toMap(null));
assertIllegalArgumentException(() -> ArrayUtils.toMap(new String[][] { { "foo", "bar" }, { "short" } }));
assertIllegalArgumentException(() -> ArrayUtils.toMap(new Object[] { new Object[] { "foo", "bar" }, "illegal type" }));
assertIllegalArgumentException(() -> ArrayUtils.toMap(new Object[] { new Object[] { "foo", "bar" }, null }));
map = ArrayUtils.toMap(new Object[] { new Map.Entry<Object, Object>() {
@Override
public boolean equals(final Object o) {
throw new UnsupportedOperationException();
}
@Override
public Object getKey() {
return "foo";
}
@Override
public Object getValue() {
return "bar";
}
@Override
public int hashCode() {
throw new UnsupportedOperationException();
}
@Override
public Object setValue(final Object value) {
throw new UnsupportedOperationException();
}
} });
assertEquals("bar", map.get("foo"));
// Return empty map when got input array with length = 0
assertEquals(Collections.emptyMap(), ArrayUtils.toMap(new Object[0]));
// Test all null values
map = ArrayUtils.toMap(new Object[][] { { null, null }, { null, null } });
assertEquals(Collections.singletonMap(null, null), map);
// Test duplicate keys
map = ArrayUtils.toMap(new Object[][] { { "key", "value2" }, { "key", "value1" } });
assertEquals(Collections.singletonMap("key", "value1"), map);
}
@Test
void testToObject_boolean() {
final boolean[] b = null;
assertArrayEquals(null, ArrayUtils.toObject(b));
assertSame(ArrayUtils.EMPTY_BOOLEAN_OBJECT_ARRAY, ArrayUtils.toObject(new boolean[0]));
assertArrayEquals(new Boolean[]{Boolean.TRUE, Boolean.FALSE, Boolean.TRUE}, ArrayUtils.toObject(new boolean[]{true, false, true}));
}
@Test
void testToObject_byte() {
final byte[] b = null;
assertArrayEquals(null, ArrayUtils.toObject(b));
assertSame(ArrayUtils.EMPTY_BYTE_OBJECT_ARRAY, ArrayUtils.toObject(new byte[0]));
assertArrayEquals(new Byte[] { Byte.valueOf(Byte.MIN_VALUE), Byte.valueOf(Byte.MAX_VALUE), Byte.valueOf((byte) 9999999) },
ArrayUtils.toObject(new byte[] { Byte.MIN_VALUE, Byte.MAX_VALUE, (byte) 9999999 }));
}
@Test
void testToObject_char() {
final char[] b = null;
assertArrayEquals(null, ArrayUtils.toObject(b));
assertSame(ArrayUtils.EMPTY_CHARACTER_OBJECT_ARRAY, ArrayUtils.toObject(new char[0]));
assertArrayEquals(new Character[] { Character.valueOf(Character.MIN_VALUE), Character.valueOf(Character.MAX_VALUE), Character.valueOf('0') },
ArrayUtils.toObject(new char[] { Character.MIN_VALUE, Character.MAX_VALUE, '0' }));
}
@Test
void testToObject_double() {
final double[] b = null;
assertArrayEquals(null, ArrayUtils.toObject(b));
assertSame(ArrayUtils.EMPTY_DOUBLE_OBJECT_ARRAY, ArrayUtils.toObject(new double[0]));
assertArrayEquals(new Double[] { Double.valueOf(Double.MIN_VALUE), Double.valueOf(Double.MAX_VALUE), Double.valueOf(9999999) },
ArrayUtils.toObject(new double[] { Double.MIN_VALUE, Double.MAX_VALUE, 9999999 }));
}
@Test
void testToObject_float() {
final float[] b = null;
assertArrayEquals(null, ArrayUtils.toObject(b));
assertSame(ArrayUtils.EMPTY_FLOAT_OBJECT_ARRAY, ArrayUtils.toObject(new float[0]));
assertArrayEquals(new Float[] { Float.valueOf(Float.MIN_VALUE), Float.valueOf(Float.MAX_VALUE), Float.valueOf(9999999) },
ArrayUtils.toObject(new float[] { Float.MIN_VALUE, Float.MAX_VALUE, 9999999 }));
}
@Test
void testToObject_int() {
final int[] b = null;
assertArrayEquals(null, ArrayUtils.toObject(b));
assertSame(ArrayUtils.EMPTY_INTEGER_OBJECT_ARRAY, ArrayUtils.toObject(new int[0]));
assertArrayEquals(new Integer[] { Integer.valueOf(Integer.MIN_VALUE), Integer.valueOf(Integer.MAX_VALUE), Integer.valueOf(9999999) },
ArrayUtils.toObject(new int[] { Integer.MIN_VALUE, Integer.MAX_VALUE, 9999999 }));
}
@Test
void testToObject_long() {
final long[] b = null;
assertArrayEquals(null, ArrayUtils.toObject(b));
assertSame(ArrayUtils.EMPTY_LONG_OBJECT_ARRAY, ArrayUtils.toObject(new long[0]));
assertArrayEquals(new Long[] { Long.valueOf(Long.MIN_VALUE), Long.valueOf(Long.MAX_VALUE), Long.valueOf(9999999) },
ArrayUtils.toObject(new long[] { Long.MIN_VALUE, Long.MAX_VALUE, 9999999 }));
}
@Test
void testToObject_short() {
final short[] b = null;
assertArrayEquals(null, ArrayUtils.toObject(b));
assertSame(ArrayUtils.EMPTY_SHORT_OBJECT_ARRAY, ArrayUtils.toObject(new short[0]));
assertArrayEquals(new Short[] { Short.valueOf(Short.MIN_VALUE), Short.valueOf(Short.MAX_VALUE), Short.valueOf((short) 9999999) },
ArrayUtils.toObject(new short[] { Short.MIN_VALUE, Short.MAX_VALUE, (short) 9999999 }));
}
/** testToPrimitive/Object for boolean */
@Test
void testToPrimitive_boolean() {
final Boolean[] b = null;
assertNull(ArrayUtils.toPrimitive(b));
assertSame(ArrayUtils.EMPTY_BOOLEAN_ARRAY, ArrayUtils.toPrimitive(new Boolean[0]));
assertArrayEquals(new boolean[]{true, false, true}, ArrayUtils.toPrimitive(new Boolean[]{Boolean.TRUE, Boolean.FALSE, Boolean.TRUE}));
assertArrayEquals(new boolean[]{true, false}, ArrayUtils.toPrimitive(new Boolean[]{Boolean.TRUE, null}));
}
@Test
void testToPrimitive_boolean_boolean() {
assertNull(ArrayUtils.toPrimitive(null, false));
assertSame(ArrayUtils.EMPTY_BOOLEAN_ARRAY, ArrayUtils.toPrimitive(new Boolean[0], false));
assertArrayEquals(new boolean[]{true, false, true}, ArrayUtils.toPrimitive(new Boolean[]{Boolean.TRUE, Boolean.FALSE, Boolean.TRUE}, false));
assertArrayEquals(new boolean[]{true, false, false}, ArrayUtils.toPrimitive(new Boolean[]{Boolean.TRUE, null, Boolean.FALSE}, false));
assertArrayEquals(new boolean[]{true, true, false}, ArrayUtils.toPrimitive(new Boolean[]{Boolean.TRUE, null, Boolean.FALSE}, true));
}
/** testToPrimitive/Object for byte */
@Test
void testToPrimitive_byte() {
final Byte[] b = null;
assertNull(ArrayUtils.toPrimitive(b));
assertSame(ArrayUtils.EMPTY_BYTE_ARRAY, ArrayUtils.toPrimitive(new Byte[0]));
assertArrayEquals(new byte[] { Byte.MIN_VALUE, Byte.MAX_VALUE, (byte) 9999999 },
ArrayUtils.toPrimitive(new Byte[] { Byte.valueOf(Byte.MIN_VALUE), Byte.valueOf(Byte.MAX_VALUE), Byte.valueOf((byte) 9999999) }));
assertNullPointerException(() -> ArrayUtils.toPrimitive(new Byte[] { Byte.valueOf(Byte.MIN_VALUE), null }));
}
@Test
void testToPrimitive_byte_byte() {
final Byte[] b = null;
assertNull(ArrayUtils.toPrimitive(b, Byte.MIN_VALUE));
assertSame(ArrayUtils.EMPTY_BYTE_ARRAY, ArrayUtils.toPrimitive(new Byte[0], (byte) 1));
assertArrayEquals(new byte[] { Byte.MIN_VALUE, Byte.MAX_VALUE, (byte) 9999999 }, ArrayUtils
.toPrimitive(new Byte[] { Byte.valueOf(Byte.MIN_VALUE), Byte.valueOf(Byte.MAX_VALUE), Byte.valueOf((byte) 9999999) }, Byte.MIN_VALUE));
assertArrayEquals(new byte[] { Byte.MIN_VALUE, Byte.MAX_VALUE, (byte) 9999999 },
ArrayUtils.toPrimitive(new Byte[] { Byte.valueOf(Byte.MIN_VALUE), null, Byte.valueOf((byte) 9999999) }, Byte.MAX_VALUE));
}
/** testToPrimitive/Object for byte */
@Test
void testToPrimitive_char() {
final Character[] b = null;
assertNull(ArrayUtils.toPrimitive(b));
assertSame(ArrayUtils.EMPTY_CHAR_ARRAY, ArrayUtils.toPrimitive(new Character[0]));
assertArrayEquals(new char[] { Character.MIN_VALUE, Character.MAX_VALUE, '0' }, ArrayUtils
.toPrimitive(new Character[] { Character.valueOf(Character.MIN_VALUE), Character.valueOf(Character.MAX_VALUE), Character.valueOf('0') }));
assertNullPointerException(() -> ArrayUtils.toPrimitive(new Character[] { Character.valueOf(Character.MIN_VALUE), null }));
}
@Test
void testToPrimitive_char_char() {
final Character[] b = null;
assertNull(ArrayUtils.toPrimitive(b, Character.MIN_VALUE));
assertSame(ArrayUtils.EMPTY_CHAR_ARRAY, ArrayUtils.toPrimitive(new Character[0], (char) 0));
assertArrayEquals(new char[] { Character.MIN_VALUE, Character.MAX_VALUE, '0' },
ArrayUtils.toPrimitive(
new Character[] { Character.valueOf(Character.MIN_VALUE), Character.valueOf(Character.MAX_VALUE), Character.valueOf('0') },
Character.MIN_VALUE));
assertArrayEquals(new char[] { Character.MIN_VALUE, Character.MAX_VALUE, '0' },
ArrayUtils.toPrimitive(new Character[] { Character.valueOf(Character.MIN_VALUE), null, Character.valueOf('0') }, Character.MAX_VALUE));
}
/** testToPrimitive/Object for double */
@Test
void testToPrimitive_double() {
final Double[] b = null;
assertNull(ArrayUtils.toPrimitive(b));
assertSame(ArrayUtils.EMPTY_DOUBLE_ARRAY, ArrayUtils.toPrimitive(new Double[0]));
assertArrayEquals(new double[] { Double.MIN_VALUE, Double.MAX_VALUE, 9999999 },
ArrayUtils.toPrimitive(new Double[] { Double.valueOf(Double.MIN_VALUE), Double.valueOf(Double.MAX_VALUE), Double.valueOf(9999999) }));
assertNullPointerException(() -> ArrayUtils.toPrimitive(new Float[] { Float.valueOf(Float.MIN_VALUE), null }));
}
@Test
void testToPrimitive_double_double() {
final Double[] l = null;
assertNull(ArrayUtils.toPrimitive(l, Double.MIN_VALUE));
assertSame(ArrayUtils.EMPTY_DOUBLE_ARRAY, ArrayUtils.toPrimitive(new Double[0], 1));
assertArrayEquals(new double[] { Double.MIN_VALUE, Double.MAX_VALUE, 9999999 },
ArrayUtils.toPrimitive(new Double[] { Double.valueOf(Double.MIN_VALUE), Double.valueOf(Double.MAX_VALUE), Double.valueOf(9999999) }, 1));
assertArrayEquals(new double[] { Double.MIN_VALUE, Double.MAX_VALUE, 9999999 },
ArrayUtils.toPrimitive(new Double[] { Double.valueOf(Double.MIN_VALUE), null, Double.valueOf(9999999) }, Double.MAX_VALUE));
}
/** testToPrimitive/Object for float */
@Test
void testToPrimitive_float() {
final Float[] b = null;
assertNull(ArrayUtils.toPrimitive(b));
assertSame(ArrayUtils.EMPTY_FLOAT_ARRAY, ArrayUtils.toPrimitive(new Float[0]));
assertArrayEquals(new float[] { Float.MIN_VALUE, Float.MAX_VALUE, 9999999 },
ArrayUtils.toPrimitive(new Float[] { Float.valueOf(Float.MIN_VALUE), Float.valueOf(Float.MAX_VALUE), Float.valueOf(9999999) }));
assertNullPointerException(() -> ArrayUtils.toPrimitive(new Float[] { Float.valueOf(Float.MIN_VALUE), null }));
}
@Test
void testToPrimitive_float_float() {
final Float[] l = null;
assertNull(ArrayUtils.toPrimitive(l, Float.MIN_VALUE));
assertSame(ArrayUtils.EMPTY_FLOAT_ARRAY, ArrayUtils.toPrimitive(new Float[0], 1));
assertArrayEquals(new float[] { Float.MIN_VALUE, Float.MAX_VALUE, 9999999 },
ArrayUtils.toPrimitive(new Float[] { Float.valueOf(Float.MIN_VALUE), Float.valueOf(Float.MAX_VALUE), Float.valueOf(9999999) }, 1));
assertArrayEquals(new float[] { Float.MIN_VALUE, Float.MAX_VALUE, 9999999 },
ArrayUtils.toPrimitive(new Float[] { Float.valueOf(Float.MIN_VALUE), null, Float.valueOf(9999999) }, Float.MAX_VALUE));
}
/** testToPrimitive/Object for int */
@Test
void testToPrimitive_int() {
final Integer[] b = null;
assertNull(ArrayUtils.toPrimitive(b));
assertSame(ArrayUtils.EMPTY_INT_ARRAY, ArrayUtils.toPrimitive(new Integer[0]));
assertArrayEquals(new int[] { Integer.MIN_VALUE, Integer.MAX_VALUE, 9999999 },
ArrayUtils.toPrimitive(new Integer[] { Integer.valueOf(Integer.MIN_VALUE), Integer.valueOf(Integer.MAX_VALUE), Integer.valueOf(9999999) }));
assertNullPointerException(() -> ArrayUtils.toPrimitive(new Integer[] { Integer.valueOf(Integer.MIN_VALUE), null }));
}
@Test
void testToPrimitive_int_int() {
final Long[] l = null;
assertNull(ArrayUtils.toPrimitive(l, Integer.MIN_VALUE));
assertSame(ArrayUtils.EMPTY_INT_ARRAY, ArrayUtils.toPrimitive(new Integer[0], 1));
assertArrayEquals(new int[] { Integer.MIN_VALUE, Integer.MAX_VALUE, 9999999 },
ArrayUtils.toPrimitive(new Integer[] { Integer.valueOf(Integer.MIN_VALUE), Integer.valueOf(Integer.MAX_VALUE), Integer.valueOf(9999999) }, 1));
assertArrayEquals(new int[] { Integer.MIN_VALUE, Integer.MAX_VALUE, 9999999 },
ArrayUtils.toPrimitive(new Integer[] { Integer.valueOf(Integer.MIN_VALUE), null, Integer.valueOf(9999999) }, Integer.MAX_VALUE));
}
@Test
void testToPrimitive_intNull() {
final Integer[] iArray = null;
assertNull(ArrayUtils.toPrimitive(iArray, Integer.MIN_VALUE));
}
/** testToPrimitive/Object for long */
@Test
void testToPrimitive_long() {
final Long[] b = null;
assertNull(ArrayUtils.toPrimitive(b));
assertSame(ArrayUtils.EMPTY_LONG_ARRAY, ArrayUtils.toPrimitive(new Long[0]));
assertArrayEquals(new long[] { Long.MIN_VALUE, Long.MAX_VALUE, 9999999 },
ArrayUtils.toPrimitive(new Long[] { Long.valueOf(Long.MIN_VALUE), Long.valueOf(Long.MAX_VALUE), Long.valueOf(9999999) }));
assertNullPointerException(() -> ArrayUtils.toPrimitive(new Long[] { Long.valueOf(Long.MIN_VALUE), null }));
}
@Test
void testToPrimitive_long_long() {
final Long[] l = null;
assertNull(ArrayUtils.toPrimitive(l, Long.MIN_VALUE));
assertSame(ArrayUtils.EMPTY_LONG_ARRAY, ArrayUtils.toPrimitive(new Long[0], 1));
assertArrayEquals(new long[] { Long.MIN_VALUE, Long.MAX_VALUE, 9999999 },
ArrayUtils.toPrimitive(new Long[] { Long.valueOf(Long.MIN_VALUE), Long.valueOf(Long.MAX_VALUE), Long.valueOf(9999999) }, 1));
assertArrayEquals(new long[] { Long.MIN_VALUE, Long.MAX_VALUE, 9999999 },
ArrayUtils.toPrimitive(new Long[] { Long.valueOf(Long.MIN_VALUE), null, Long.valueOf(9999999) }, Long.MAX_VALUE));
}
/** testToPrimitive/Object for short */
@Test
void testToPrimitive_short() {
final Short[] b = null;
assertNull(ArrayUtils.toPrimitive(b));
assertSame(ArrayUtils.EMPTY_SHORT_ARRAY, ArrayUtils.toPrimitive(new Short[0]));
assertArrayEquals(new short[] { Short.MIN_VALUE, Short.MAX_VALUE, (short) 9999999 },
ArrayUtils.toPrimitive(new Short[] { Short.valueOf(Short.MIN_VALUE), Short.valueOf(Short.MAX_VALUE), Short.valueOf((short) 9999999) }));
assertNullPointerException(() -> ArrayUtils.toPrimitive(new Short[] { Short.valueOf(Short.MIN_VALUE), null }));
}
@Test
void testToPrimitive_short_short() {
final Short[] s = null;
assertNull(ArrayUtils.toPrimitive(s, Short.MIN_VALUE));
assertSame(ArrayUtils.EMPTY_SHORT_ARRAY, ArrayUtils.toPrimitive(new Short[0], Short.MIN_VALUE));
assertArrayEquals(new short[] { Short.MIN_VALUE, Short.MAX_VALUE, (short) 9999999 }, ArrayUtils
.toPrimitive(new Short[] { Short.valueOf(Short.MIN_VALUE), Short.valueOf(Short.MAX_VALUE), Short.valueOf((short) 9999999) }, Short.MIN_VALUE));
assertArrayEquals(new short[] { Short.MIN_VALUE, Short.MAX_VALUE, (short) 9999999 },
ArrayUtils.toPrimitive(new Short[] { Short.valueOf(Short.MIN_VALUE), null, Short.valueOf((short) 9999999) }, Short.MAX_VALUE));
}
@Test
void testToPrimitiveArray() {
assertNull(ArrayUtils.toPrimitive((Object[]) null));
assertArrayEquals(new boolean[] { true }, ArrayUtils.toPrimitive(new Boolean[] { true }));
assertArrayEquals(new char[] { 'a' }, ArrayUtils.toPrimitive(new Character[] { 'a' }));
assertArrayEquals(new byte[] { 1 }, ArrayUtils.toPrimitive(new Byte[] { 1 }));
assertArrayEquals(new int[] {}, ArrayUtils.toPrimitive(new Integer[] {}));
assertArrayEquals(new short[] { 2 }, ArrayUtils.toPrimitive(new Short[] { 2 }));
assertArrayEquals(new long[] { 2, 3 }, ArrayUtils.toPrimitive(new Long[] { 2L, 3L }));
assertArrayEquals(new float[] { 3.14f }, ArrayUtils.toPrimitive(new Float[] { 3.14f }), 0.1f);
assertArrayEquals(new double[] { 2.718 }, ArrayUtils.toPrimitive(new Double[] { 2.718 }), 0.1);
}
@Test
void testToPrimitiveArrayViaObjectArray() {
assertNull(ArrayUtils.toPrimitive((Object) null));
assertArrayEquals(new boolean[] { true }, (boolean[]) ArrayUtils.toPrimitive((Object) new Boolean[] { true }));
assertArrayEquals(new char[] { 'a' }, (char[]) ArrayUtils.toPrimitive((Object) new Character[] { 'a' }));
assertArrayEquals(new byte[] { 1 }, (byte[]) ArrayUtils.toPrimitive((Object) new Byte[] { 1 }));
assertArrayEquals(new int[] {}, (int[]) ArrayUtils.toPrimitive((Object) new Integer[] {}));
assertArrayEquals(new short[] { 2 }, (short[]) ArrayUtils.toPrimitive((Object) new Short[] { 2 }));
assertArrayEquals(new long[] { 2, 3 }, (long[]) ArrayUtils.toPrimitive((Object) new Long[] { 2L, 3L }));
assertArrayEquals(new float[] { 3.14f }, (float[]) ArrayUtils.toPrimitive((Object) new Float[] { 3.14f }), 0.1f);
assertArrayEquals(new double[] { 2.718 }, (double[]) ArrayUtils.toPrimitive((Object) new Double[] { 2.718 }), 0.1);
assertArrayEquals(new String[] { "a" }, (String[]) ArrayUtils.toPrimitive(new String[] { "a" }));
}
@Test
void testToString() {
assertEquals("{}", ArrayUtils.toString(null));
assertEquals("{}", ArrayUtils.toString(new Object[0]));
assertEquals("{}", ArrayUtils.toString(new String[0]));
assertEquals("{<null>}", ArrayUtils.toString(new String[] { null }));
assertEquals("{pink,blue}", ArrayUtils.toString(new String[] { "pink", "blue" }));
assertEquals("{<null>,<null>}", ArrayUtils.toString(new String[] { null, null }));
}
@Test
void testToStringArray_array() {
assertNull(ArrayUtils.toStringArray(null));
assertArrayEquals(new String[0], ArrayUtils.toStringArray(new Object[0]));
assertArrayEquals(new String[] { "1", "2", "3", "array", "test" }, ArrayUtils.toStringArray(new Object[] { 1, 2, 3, "array", "test" }));
assertArrayEquals(new String[] { "null" }, ArrayUtils.toStringArray(new Object[] { null }));
assertArrayEquals(new String[] { "1", "null", "3", "null", "test" }, ArrayUtils.toStringArray(new Object[] { 1, null, 3, null, "test" }));
assertArrayEquals(new String[] { "null", "null", "null", "null", "null" }, ArrayUtils.toStringArray(new Object[] { null, null, null, null, null }));
}
@Test
void testToStringArray_array_string() {
assertNull(ArrayUtils.toStringArray(null, ""));
assertArrayEquals(new String[0], ArrayUtils.toStringArray(new Object[0], ""));
assertArrayEquals(new String[] { "1", "MyNull", "test" }, ArrayUtils.toStringArray(new Object[] { 1, null, "test" }, "MyNull"));
assertArrayEquals(new String[] { "MyNull" }, ArrayUtils.toStringArray(new Object[] { null }, "MyNull"));
assertArrayEquals(new String[] { "MyNull", "MyNull" }, ArrayUtils.toStringArray(new Object[] { null, null }, "MyNull"));
}
@Test
void testToStringDefault() {
assertEquals("<empty>", ArrayUtils.toString(null, "<empty>"));
assertEquals("{}", ArrayUtils.toString(new Object[0], "<empty>"));
assertEquals("{}", ArrayUtils.toString(new String[0], "<empty>"));
assertEquals("{<null>}", ArrayUtils.toString(new String[]{null}, "<empty>"));
assertEquals("{pink,blue}", ArrayUtils.toString(new String[]{"pink", "blue"}, "<empty>"));
}
}
| LANG1261ChildObject |
java | netty__netty | codec-http/src/main/java/io/netty/handler/codec/rtsp/RtspHeaderNames.java | {
"start": 987,
"end": 6405
} | class ____ {
/**
* {@code "accept"}
*/
public static final AsciiString ACCEPT = HttpHeaderNames.ACCEPT;
/**
* {@code "accept-encoding"}
*/
public static final AsciiString ACCEPT_ENCODING = HttpHeaderNames.ACCEPT_ENCODING;
/**
* {@code "accept-language"}
*/
public static final AsciiString ACCEPT_LANGUAGE = HttpHeaderNames.ACCEPT_LANGUAGE;
/**
* {@code "allow"}
*/
public static final AsciiString ALLOW = AsciiString.cached("allow");
/**
* {@code "authorization"}
*/
public static final AsciiString AUTHORIZATION = HttpHeaderNames.AUTHORIZATION;
/**
* {@code "bandwidth"}
*/
public static final AsciiString BANDWIDTH = AsciiString.cached("bandwidth");
/**
* {@code "blocksize"}
*/
public static final AsciiString BLOCKSIZE = AsciiString.cached("blocksize");
/**
* {@code "cache-control"}
*/
public static final AsciiString CACHE_CONTROL = HttpHeaderNames.CACHE_CONTROL;
/**
* {@code "conference"}
*/
public static final AsciiString CONFERENCE = AsciiString.cached("conference");
/**
* {@code "connection"}
*/
public static final AsciiString CONNECTION = HttpHeaderNames.CONNECTION;
/**
* {@code "content-base"}
*/
public static final AsciiString CONTENT_BASE = HttpHeaderNames.CONTENT_BASE;
/**
* {@code "content-encoding"}
*/
public static final AsciiString CONTENT_ENCODING = HttpHeaderNames.CONTENT_ENCODING;
/**
* {@code "content-language"}
*/
public static final AsciiString CONTENT_LANGUAGE = HttpHeaderNames.CONTENT_LANGUAGE;
/**
* {@code "content-length"}
*/
public static final AsciiString CONTENT_LENGTH = HttpHeaderNames.CONTENT_LENGTH;
/**
* {@code "content-location"}
*/
public static final AsciiString CONTENT_LOCATION = HttpHeaderNames.CONTENT_LOCATION;
/**
* {@code "content-type"}
*/
public static final AsciiString CONTENT_TYPE = HttpHeaderNames.CONTENT_TYPE;
/**
* {@code "cseq"}
*/
public static final AsciiString CSEQ = AsciiString.cached("cseq");
/**
* {@code "date"}
*/
public static final AsciiString DATE = HttpHeaderNames.DATE;
/**
* {@code "expires"}
*/
public static final AsciiString EXPIRES = HttpHeaderNames.EXPIRES;
/**
* {@code "from"}
*/
public static final AsciiString FROM = HttpHeaderNames.FROM;
/**
* {@code "host"}
*/
public static final AsciiString HOST = HttpHeaderNames.HOST;
/**
* {@code "if-match"}
*/
public static final AsciiString IF_MATCH = HttpHeaderNames.IF_MATCH;
/**
* {@code "if-modified-since"}
*/
public static final AsciiString IF_MODIFIED_SINCE = HttpHeaderNames.IF_MODIFIED_SINCE;
/**
* {@code "keymgmt"}
*/
public static final AsciiString KEYMGMT = AsciiString.cached("keymgmt");
/**
* {@code "last-modified"}
*/
public static final AsciiString LAST_MODIFIED = HttpHeaderNames.LAST_MODIFIED;
/**
* {@code "proxy-authenticate"}
*/
public static final AsciiString PROXY_AUTHENTICATE = HttpHeaderNames.PROXY_AUTHENTICATE;
/**
* {@code "proxy-require"}
*/
public static final AsciiString PROXY_REQUIRE = AsciiString.cached("proxy-require");
/**
* {@code "public"}
*/
public static final AsciiString PUBLIC = AsciiString.cached("public");
/**
* {@code "range"}
*/
public static final AsciiString RANGE = HttpHeaderNames.RANGE;
/**
* {@code "referer"}
*/
public static final AsciiString REFERER = HttpHeaderNames.REFERER;
/**
* {@code "require"}
*/
public static final AsciiString REQUIRE = AsciiString.cached("require");
/**
* {@code "retry-after"}
*/
public static final AsciiString RETRT_AFTER = HttpHeaderNames.RETRY_AFTER;
/**
* {@code "rtp-info"}
*/
public static final AsciiString RTP_INFO = AsciiString.cached("rtp-info");
/**
* {@code "scale"}
*/
public static final AsciiString SCALE = AsciiString.cached("scale");
/**
* {@code "session"}
*/
public static final AsciiString SESSION = AsciiString.cached("session");
/**
* {@code "server"}
*/
public static final AsciiString SERVER = HttpHeaderNames.SERVER;
/**
* {@code "speed"}
*/
public static final AsciiString SPEED = AsciiString.cached("speed");
/**
* {@code "timestamp"}
*/
public static final AsciiString TIMESTAMP = AsciiString.cached("timestamp");
/**
* {@code "transport"}
*/
public static final AsciiString TRANSPORT = AsciiString.cached("transport");
/**
* {@code "unsupported"}
*/
public static final AsciiString UNSUPPORTED = AsciiString.cached("unsupported");
/**
* {@code "user-agent"}
*/
public static final AsciiString USER_AGENT = HttpHeaderNames.USER_AGENT;
/**
* {@code "vary"}
*/
public static final AsciiString VARY = HttpHeaderNames.VARY;
/**
* {@code "via"}
*/
public static final AsciiString VIA = HttpHeaderNames.VIA;
/**
* {@code "www-authenticate"}
*/
public static final AsciiString WWW_AUTHENTICATE = HttpHeaderNames.WWW_AUTHENTICATE;
private RtspHeaderNames() { }
}
| RtspHeaderNames |
java | spring-projects__spring-framework | spring-beans/src/main/java/org/springframework/beans/factory/annotation/AutowiredAnnotationBeanPostProcessor.java | {
"start": 28417,
"end": 29674
} | class ____ via ASM for determining @Autowired method order", ex);
// No worries, let's continue with the reflection metadata we started with...
}
}
return methodElements;
}
/**
* Register the specified bean as dependent on the autowired beans.
*/
private void registerDependentBeans(@Nullable String beanName, Set<String> autowiredBeanNames) {
if (beanName != null) {
for (String autowiredBeanName : autowiredBeanNames) {
if (this.beanFactory != null && this.beanFactory.containsBean(autowiredBeanName)) {
this.beanFactory.registerDependentBean(autowiredBeanName, beanName);
}
if (logger.isTraceEnabled()) {
logger.trace("Autowiring by type from bean name '" + beanName +
"' to bean named '" + autowiredBeanName + "'");
}
}
}
}
/**
* Resolve the specified cached method argument or field value.
*/
private @Nullable Object resolveCachedArgument(@Nullable String beanName, @Nullable Object cachedArgument) {
if (cachedArgument instanceof DependencyDescriptor descriptor) {
Assert.state(this.beanFactory != null, "No BeanFactory available");
return this.beanFactory.resolveDependency(descriptor, beanName, null, null);
}
else {
return cachedArgument;
}
}
/**
* Base | file |
java | playframework__playframework | testkit/play-test/src/main/java/play/test/Helpers.java | {
"start": 20745,
"end": 22189
} | class ____ webdriver.
* @param port the local port to test against.
* @return the test browser.
*/
public static TestBrowser testBrowser(Class<? extends WebDriver> webDriver, int port) {
try {
return new TestBrowser(webDriver, "http://localhost:" + port);
} catch (RuntimeException e) {
throw e;
} catch (Throwable t) {
throw new RuntimeException(t);
}
}
/**
* Creates a Test Browser.
*
* @param of the web driver to run the browser with.
* @param port the port to run against http://localhost
* @return the test browser.
*/
public static TestBrowser testBrowser(WebDriver of, int port) {
return new TestBrowser(of, "http://localhost:" + port);
}
/**
* Creates a Test Browser.
*
* <p>Be aware: If set, the port the test browser is using is defined by the system property
* "testserver.port". Starting with Play 2.9, if this property is not set, the port by default is
* 0, which means the operating system will assign a random port. Thus, you should only use this
* method here if you did explicitly set the "testserver.port" property, otherwise you should use
* the testBrowser(of, port) method (which takes a port param).
*
* @param of the web driver to run the browser with.
* @return the test browser.
*/
public static TestBrowser testBrowser(WebDriver of) {
return testBrowser(of, Helpers$.MODULE$.testServerPort());
}
}
| of |
java | apache__flink | flink-streaming-java/src/main/java/org/apache/flink/streaming/api/functions/async/AsyncRetryPredicate.java | {
"start": 1096,
"end": 1833
} | interface ____<OUT> {
/**
* An Optional Java {@Predicate} that defines a condition on asyncFunction's future result which
* will trigger a later reattempt operation, will be called before user's ResultFuture#complete.
*
* @return predicate on result of {@link Collection}
*/
Optional<Predicate<Collection<OUT>>> resultPredicate();
/**
* An Optional Java {@Predicate} that defines a condition on asyncFunction's exception which
* will trigger a later reattempt operation, will be called before user's
* ResultFuture#completeExceptionally.
*
* @return predicate on {@link Throwable} exception
*/
Optional<Predicate<Throwable>> exceptionPredicate();
}
| AsyncRetryPredicate |
java | processing__processing4 | app/src/processing/app/ui/ColorChooser.java | {
"start": 18131,
"end": 18230
} | class ____
// seems to have something to do with how Document objects are set up
}
}
}
| here |
java | alibaba__nacos | api/src/main/java/com/alibaba/nacos/api/ai/model/mcp/registry/StreamableHttpTransport.java | {
"start": 1166,
"end": 1741
} | class ____ {
private String type = "streamable-http";
private String url;
private List<KeyValueInput> headers;
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public String getUrl() {
return url;
}
public void setUrl(String url) {
this.url = url;
}
public List<KeyValueInput> getHeaders() {
return headers;
}
public void setHeaders(List<KeyValueInput> headers) {
this.headers = headers;
}
}
| StreamableHttpTransport |
java | hibernate__hibernate-orm | hibernate-core/src/test/java/org/hibernate/orm/test/query/EmbeddedForeignKeyInSubqueryTest.java | {
"start": 3128,
"end": 3514
} | class ____ implements Serializable {
private String name;
private Integer code;
public EnvironmentKey() {
}
public EnvironmentKey(String name, Integer code) {
this.name = name;
this.code = code;
}
public String getName() {
return name;
}
public Integer getCode() {
return code;
}
}
@Entity( name = "EnvironmentEntity" )
public static | EnvironmentKey |
java | eclipse-vertx__vert.x | vertx-core/src/test/java/io/vertx/it/json/CustomJsonFactory.java | {
"start": 882,
"end": 2296
} | class ____ implements JsonFactory {
public static final JsonCodec CODEC = new JsonCodec() {
@Override
public <T> T fromString(String json, Class<T> clazz) throws DecodeException {
throw new UnsupportedOperationException();
}
@Override
public <T> T fromBuffer(Buffer json, Class<T> clazz) throws DecodeException {
throw new UnsupportedOperationException();
}
@Override
public <T> T fromValue(Object json, Class<T> toValueType) {
throw new UnsupportedOperationException();
}
@Override
public String toString(Object object, boolean pretty) throws EncodeException {
if (object instanceof JsonObject) {
return ((JsonObject) object).stream()
.map(member -> "\"" + member.getKey() + "\":" + toString(member.getValue(), pretty))
.collect(Collectors.joining(",", "{", "}"));
} else if (object instanceof JsonArray) {
return ((JsonArray) object).stream().map(elt -> toString(elt, pretty)).collect(Collectors.joining(",", "[", "]"));
} else if (object instanceof String) {
return "\"" + object + "\"";
} else {
return object.toString();
}
}
@Override
public Buffer toBuffer(Object object, boolean pretty) throws EncodeException {
return Buffer.buffer(toString(object));
}
};
@Override
public JsonCodec codec() {
return CODEC;
}
}
| CustomJsonFactory |
java | elastic__elasticsearch | x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/registry/ModelRegistryTests.java | {
"start": 1601,
"end": 8303
} | class ____ extends ESSingleNodeTestCase {
private static final TimeValue TIMEOUT = new TimeValue(30, TimeUnit.SECONDS);
private ModelRegistry registry;
@Override
protected Collection<Class<? extends Plugin>> getPlugins() {
return pluginList(ReindexPlugin.class, LocalStateInferencePlugin.class);
}
@Before
public void createComponents() {
registry = node().injector().getInstance(ModelRegistry.class);
}
public void testRemoveDefaultConfigs_DoesNotCallClient_WhenPassedAnEmptySet() {
var listener = new PlainActionFuture<Boolean>();
registry.removeDefaultConfigs(Set.of(), listener);
assertTrue(listener.actionGet(TIMEOUT));
}
public void testDeleteModels_Returns_ConflictException_WhenModelIsBeingAdded() {
var model = TestModel.createRandomInstance();
var newModel = TestModel.createRandomInstance();
registry.updateModelTransaction(newModel, model, new PlainActionFuture<>());
var listener = new PlainActionFuture<Boolean>();
registry.deleteModels(Set.of(newModel.getInferenceEntityId()), listener);
var exception = expectThrows(ElasticsearchStatusException.class, () -> listener.actionGet(TIMEOUT));
assertThat(
exception.getMessage(),
containsString("are currently being updated, please wait until after they are finished updating to delete.")
);
assertThat(exception.status(), is(RestStatus.CONFLICT));
}
public void testIdMatchedDefault() {
var defaultConfigIds = new ArrayList<InferenceService.DefaultConfigId>();
defaultConfigIds.add(
new InferenceService.DefaultConfigId("foo", MinimalServiceSettings.sparseEmbedding("my_service"), mock(InferenceService.class))
);
defaultConfigIds.add(
new InferenceService.DefaultConfigId("bar", MinimalServiceSettings.sparseEmbedding("my_service"), mock(InferenceService.class))
);
var matched = ModelRegistry.idMatchedDefault("bar", defaultConfigIds);
assertEquals(defaultConfigIds.get(1), matched.get());
matched = ModelRegistry.idMatchedDefault("baz", defaultConfigIds);
assertFalse(matched.isPresent());
}
public void testContainsPreconfiguredInferenceEndpointId() {
registry.addDefaultIds(
new InferenceService.DefaultConfigId("foo", MinimalServiceSettings.sparseEmbedding("my_service"), mock(InferenceService.class))
);
registry.addDefaultIds(
new InferenceService.DefaultConfigId("bar", MinimalServiceSettings.sparseEmbedding("my_service"), mock(InferenceService.class))
);
assertTrue(registry.containsPreconfiguredInferenceEndpointId("foo"));
assertFalse(registry.containsPreconfiguredInferenceEndpointId("baz"));
}
public void testTaskTypeMatchedDefaults() {
var defaultConfigIds = new ArrayList<InferenceService.DefaultConfigId>();
defaultConfigIds.add(
new InferenceService.DefaultConfigId("s1", MinimalServiceSettings.sparseEmbedding("my_service"), mock(InferenceService.class))
);
defaultConfigIds.add(
new InferenceService.DefaultConfigId("s2", MinimalServiceSettings.sparseEmbedding("my_service"), mock(InferenceService.class))
);
defaultConfigIds.add(
new InferenceService.DefaultConfigId(
"d1",
MinimalServiceSettings.textEmbedding("my_service", 384, SimilarityMeasure.COSINE, DenseVectorFieldMapper.ElementType.FLOAT),
mock(InferenceService.class)
)
);
defaultConfigIds.add(
new InferenceService.DefaultConfigId("c1", MinimalServiceSettings.completion("my_service"), mock(InferenceService.class))
);
var matched = ModelRegistry.taskTypeMatchedDefaults(TaskType.SPARSE_EMBEDDING, defaultConfigIds);
assertThat(matched, contains(defaultConfigIds.get(0), defaultConfigIds.get(1)));
matched = ModelRegistry.taskTypeMatchedDefaults(TaskType.TEXT_EMBEDDING, defaultConfigIds);
assertThat(matched, contains(defaultConfigIds.get(2)));
matched = ModelRegistry.taskTypeMatchedDefaults(TaskType.RERANK, defaultConfigIds);
assertThat(matched, empty());
}
public void testDuplicateDefaultIds() {
var id = "my-inference";
var mockServiceA = mock(InferenceService.class);
when(mockServiceA.name()).thenReturn("service-a");
var mockServiceB = mock(InferenceService.class);
when(mockServiceB.name()).thenReturn("service-b");
registry.addDefaultIds(new InferenceService.DefaultConfigId(id, MinimalServiceSettingsTests.randomInstance(), mockServiceA));
var ise = expectThrows(
IllegalStateException.class,
() -> registry.addDefaultIds(
new InferenceService.DefaultConfigId(id, MinimalServiceSettingsTests.randomInstance(), mockServiceB)
)
);
assertThat(
ise.getMessage(),
containsString(
"Cannot add default endpoint to the inference endpoint registry with duplicate inference id [my-inference] declared by "
+ "service [service-b]. The inference Id is already use by [service-a] service."
)
);
}
public void testDeleteModels_Succeeds_WhenNoInferenceIdsAreProvided() {
var model = TestModel.createRandomInstance();
assertStoreModel(registry, model);
var listener = new PlainActionFuture<Boolean>();
registry.deleteModels(Set.of(), listener);
assertTrue(listener.actionGet(TIMEOUT));
}
public static void assertStoreModel(ModelRegistry registry, Model model) {
PlainActionFuture<Boolean> storeListener = new PlainActionFuture<>();
registry.storeModel(model, storeListener, TimeValue.THIRTY_SECONDS);
assertTrue(storeListener.actionGet(TimeValue.THIRTY_SECONDS));
assertMinimalServiceSettings(registry, model);
}
public static void assertMinimalServiceSettings(ModelRegistry registry, Model model) {
var settings = registry.getMinimalServiceSettings(model.getInferenceEntityId());
assertNotNull(settings);
assertThat(settings.taskType(), Matchers.equalTo(model.getTaskType()));
assertThat(settings.dimensions(), Matchers.equalTo(model.getServiceSettings().dimensions()));
assertThat(settings.elementType(), Matchers.equalTo(model.getServiceSettings().elementType()));
assertThat(settings.dimensions(), Matchers.equalTo(model.getServiceSettings().dimensions()));
}
}
| ModelRegistryTests |
java | elastic__elasticsearch | build-tools-internal/src/test/java/org/elasticsearch/gradle/internal/test/rest/transform/match/ReplaceKeyInMatchTests.java | {
"start": 837,
"end": 1600
} | class ____ extends TransformTests {
@Test
public void testReplaceKeyInMatch() throws Exception {
String test_original = "/rest/transform/match/key_replace/replace_key_in_match_original.yml";
List<ObjectNode> tests = getTests(test_original);
String test_transformed = "/rest/transform/match/key_replace/replace_key_in_match_transformed.yml";
List<ObjectNode> expectedTransformation = getTests(test_transformed);
List<ObjectNode> transformedTests = transformTests(
tests,
Collections.singletonList(new ReplaceKeyInMatch("match.key.to_replace", "match.key.replaced", null))
);
AssertObjectNodes.areEqual(transformedTests, expectedTransformation);
}
}
| ReplaceKeyInMatchTests |
java | elastic__elasticsearch | x-pack/plugin/logsdb/src/main/java/org/elasticsearch/xpack/logsdb/patterntext/PatternTextDocValues.java | {
"start": 597,
"end": 3450
} | class ____ extends BinaryDocValues {
private final SortedSetDocValues templateDocValues;
private final SortedSetDocValues argsDocValues;
private final SortedSetDocValues argsInfoDocValues;
PatternTextDocValues(SortedSetDocValues templateDocValues, SortedSetDocValues argsDocValues, SortedSetDocValues argsInfoDocValues) {
this.templateDocValues = templateDocValues;
this.argsDocValues = argsDocValues;
this.argsInfoDocValues = argsInfoDocValues;
}
static PatternTextDocValues from(LeafReader leafReader, String templateFieldName, String argsFieldName, String argsInfoFieldName)
throws IOException {
SortedSetDocValues templateDocValues = DocValues.getSortedSet(leafReader, templateFieldName);
SortedSetDocValues argsDocValues = DocValues.getSortedSet(leafReader, argsFieldName);
SortedSetDocValues argsInfoDocValues = DocValues.getSortedSet(leafReader, argsInfoFieldName);
return new PatternTextDocValues(templateDocValues, argsDocValues, argsInfoDocValues);
}
private String getNextStringValue() throws IOException {
assert templateDocValues.docValueCount() == 1;
assert argsInfoDocValues.docValueCount() == 1;
String template = templateDocValues.lookupOrd(templateDocValues.nextOrd()).utf8ToString();
List<Arg.Info> argsInfo = Arg.decodeInfo(argsInfoDocValues.lookupOrd(argsInfoDocValues.nextOrd()).utf8ToString());
if (argsInfo.isEmpty() == false) {
assert argsDocValues.docValueCount() == 1;
var mergedArgs = argsDocValues.lookupOrd(argsDocValues.nextOrd());
var args = Arg.decodeRemainingArgs(mergedArgs.utf8ToString());
assert args.length == argsInfo.size();
return PatternTextValueProcessor.merge(template, args, argsInfo);
} else {
return template;
}
}
@Override
public BytesRef binaryValue() throws IOException {
return new BytesRef(getNextStringValue());
}
@Override
public boolean advanceExact(int i) throws IOException {
argsDocValues.advanceExact(i);
argsInfoDocValues.advanceExact(i);
// If template has a value, then message has a value. We don't have to check args here, since there may not be args for the doc
return templateDocValues.advanceExact(i);
}
@Override
public int docID() {
return templateDocValues.docID();
}
@Override
public int nextDoc() throws IOException {
throw new UnsupportedOperationException();
}
@Override
public int advance(int i) throws IOException {
throw new UnsupportedOperationException();
}
@Override
public long cost() {
return templateDocValues.cost() + argsDocValues.cost() + argsInfoDocValues.cost();
}
}
| PatternTextDocValues |
java | assertj__assertj-core | assertj-core/src/main/java/org/assertj/core/error/ShouldBeSubsetOf.java | {
"start": 1002,
"end": 2423
} | class ____ extends BasicErrorMessageFactory {
/**
* Creates a new <code>{@link ShouldBeSubsetOf}</code>
* @param actual the actual set
* @param values the expected superset
* @param unexpected the unexpected value
* @param comparisonStrategy the <code>{@link ComparisonStrategy}</code> used
* @return the created <code>{@link ErrorMessageFactory}</code>
*/
public static ErrorMessageFactory shouldBeSubsetOf(Object actual, Object values, Iterable<?> unexpected,
ComparisonStrategy comparisonStrategy) {
return new ShouldBeSubsetOf(actual, values, unexpected, comparisonStrategy);
}
/**
* Creates a new <code>{@link ShouldBeSubsetOf}</code>.
* @param actual the actual set
* @param values the expected superset
* @param unexpected the unexpected value
* @return the created {@code ErrorMessageFactory}.
*/
public static ErrorMessageFactory shouldBeSubsetOf(Object actual, Object values, Iterable<?> unexpected) {
return new ShouldBeSubsetOf(actual, values, unexpected, StandardComparisonStrategy.instance());
}
private ShouldBeSubsetOf(Object actual, Object values, Iterable<?> unexpected, ComparisonStrategy comparisonStrategy) {
super("%nExpecting %s:%n %s%nto be subset of%n %s%nbut found these extra elements:%n %s", comparisonStrategy, actual,
values, unexpected);
}
}
| ShouldBeSubsetOf |
java | apache__camel | core/camel-core/src/test/java/org/apache/camel/processor/interceptor/AdviceWithAutoStartupTest.java | {
"start": 1205,
"end": 2741
} | class ____ extends ContextTestSupport {
@Test
public void testAdvised() throws Exception {
assertFalse(context.getRouteController().getRouteStatus("foo").isStarted());
assertFalse(context.getRouteController().getRouteStatus("bar").isStarted());
AdviceWith.adviceWith(context.getRouteDefinition("bar"), context, new AdviceWithRouteBuilder() {
@Override
public void configure() {
replaceFromWith("seda:newBar");
}
});
assertFalse(context.getRouteController().getRouteStatus("foo").isStarted());
assertFalse(context.getRouteController().getRouteStatus("bar").isStarted());
context.getRouteController().startRoute("foo");
context.getRouteController().startRoute("bar");
assertTrue(context.getRouteController().getRouteStatus("foo").isStarted());
assertTrue(context.getRouteController().getRouteStatus("bar").isStarted());
getMockEndpoint("mock:newBar").expectedMessageCount(1);
template.sendBody("direct:start", "Hello World");
assertMockEndpointsSatisfied();
}
@Override
protected RouteBuilder createRouteBuilder() {
return new RouteBuilder() {
@Override
public void configure() {
context.setAutoStartup(false);
from("direct:start").routeId("foo").to("seda:newBar");
from("seda:bar").routeId("bar").to("mock:newBar");
}
};
}
}
| AdviceWithAutoStartupTest |
java | quarkusio__quarkus | extensions/resteasy-reactive/rest-csrf/deployment/src/test/java/io/quarkus/csrf/reactive/CsrfTest.java | {
"start": 817,
"end": 5211
} | class ____ {
@RegisterExtension
static final QuarkusUnitTest config = new QuarkusUnitTest()
.withApplicationRoot((jar) -> jar
.addClasses(TestResource.class)
.addAsResource("templates/csrfToken.html"));
private final static String COOKIE_NAME = "csrf-token";
private final static String HEADER_NAME = "X-CSRF-TOKEN";
@Test
public void testForm() {
String token = when()
.get("/csrfTokenForm")
.then()
.statusCode(200)
.cookie(COOKIE_NAME)
.extract()
.cookie(COOKIE_NAME);
EncoderConfig encoderConfig = EncoderConfig.encoderConfig().encodeContentTypeAs("multipart/form-data",
ContentType.TEXT);
RestAssuredConfig restAssuredConfig = RestAssured.config().encoderConfig(encoderConfig);
//no token
given()
.cookie(COOKIE_NAME, token)
.config(restAssuredConfig)
.formParam("name", "testName")
.contentType(ContentType.URLENC)
.when()
.post("csrfTokenForm")
.then()
.statusCode(400);
//wrong token
given()
.cookie(COOKIE_NAME, token)
.config(restAssuredConfig)
.formParam(COOKIE_NAME, "WRONG")
.formParam("name", "testName")
.contentType(ContentType.URLENC)
.when()
.post("csrfTokenForm")
.then()
.statusCode(400);
//valid token
given()
.cookie(COOKIE_NAME, token)
.config(restAssuredConfig)
.formParam(COOKIE_NAME, token)
.formParam("name", "testName")
.contentType(ContentType.URLENC)
.when()
.post("csrfTokenForm")
.then()
.statusCode(200)
.body(Matchers.equalTo("testName"));
}
@Test
public void testNoBody() {
String token = when().get("/csrfTokenForm")
.then().statusCode(200).cookie(COOKIE_NAME)
.extract().cookie(COOKIE_NAME);
// no token
given()
.cookie(COOKIE_NAME, token)
.when()
.post("csrfTokenPost")
.then()
.statusCode(400);
//wrong token
given()
.cookie(COOKIE_NAME, token)
.header(HEADER_NAME, "WRONG")
.when()
.post("csrfTokenPost")
.then()
.statusCode(400);
//valid token
given()
.cookie(COOKIE_NAME, token)
.header(HEADER_NAME, token)
.when()
.post("csrfTokenPost")
.then()
.statusCode(200)
.body(Matchers.equalTo("no user"));
}
@Test
public void testWithBody() {
String token = when()
.get("/csrfTokenForm")
.then()
.statusCode(200)
.cookie(COOKIE_NAME)
.extract()
.cookie(COOKIE_NAME);
// no token
given()
.cookie(COOKIE_NAME, token)
.body("testName")
.contentType(ContentType.TEXT)
.when()
.post("csrfTokenPostBody")
.then()
.statusCode(400);
//wrong token
given()
.cookie(COOKIE_NAME, token)
.header(HEADER_NAME, "WRONG")
.body("testName")
.contentType(ContentType.TEXT)
.when()
.post("csrfTokenPostBody")
.then()
.statusCode(400);
//valid token => This test fails but should work
given()
.cookie(COOKIE_NAME, token)
.header(HEADER_NAME, token)
.body("testName")
.contentType(ContentType.TEXT)
.when()
.post("csrfTokenPostBody")
.then()
.statusCode(200)
.body(Matchers.equalTo("testName"));
}
@Path("")
public static | CsrfTest |
java | google__error-prone | core/src/test/java/com/google/errorprone/bugpatterns/DeeplyNestedTest.java | {
"start": 887,
"end": 1402
} | class ____ {
private final CompilationTestHelper testHelper =
CompilationTestHelper.newInstance(DeeplyNested.class, getClass());
private final BugCheckerRefactoringTestHelper refactoringTestHelper =
BugCheckerRefactoringTestHelper.newInstance(DeeplyNested.class, getClass());
@Test
public void refactoringReturn() {
refactoringTestHelper
.addInputLines(
"Test.java",
"""
import com.google.common.collect.ImmutableList;
| DeeplyNestedTest |
java | apache__flink | flink-test-utils-parent/flink-test-utils/src/main/java/org/apache/flink/test/util/MultipleProgramsTestBaseJUnit4.java | {
"start": 2014,
"end": 2267
} | class ____ extends AbstractTestBaseJUnit4 {
/**
* Enum that defines which execution environment to run the next test on: An embedded local
* flink cluster, or the collection execution backend.
*/
public | MultipleProgramsTestBaseJUnit4 |
java | hibernate__hibernate-orm | hibernate-core/src/test/java/org/hibernate/orm/test/entitygraph/ast/EntityGraphLoadPlanBuilderTest.java | {
"start": 17926,
"end": 18050
} | class ____ {
@Id
String name;
@ElementCollection
Set<Address> shipAddresses;
}
@Entity
public static | ExpressCompany |
java | apache__flink | flink-libraries/flink-cep/src/test/java/org/apache/flink/cep/operator/CEPMigrationTest.java | {
"start": 29479,
"end": 29766
} | class ____ extends SimpleCondition<SubEvent> {
private static final long serialVersionUID = 7056763917392056548L;
@Override
public boolean filter(SubEvent value) throws Exception {
return value.getName().equals("end");
}
}
}
| SubEventEndFilter |
java | quarkusio__quarkus | extensions/flyway/deployment/src/test/java/io/quarkus/flyway/test/FlywayExtensionWithMultipleDatasourcesAndCustomizersTest.java | {
"start": 3761,
"end": 4080
} | class ____ implements FlywayConfigurationCustomizer {
@Override
public void customize(FluentConfiguration configuration) {
configuration.callbacks(new FlywayExtensionCallback());
}
}
@Singleton
@FlywayDataSource("users")
public static | AddCallbacksCustomizerForDefaultDS |
java | lettuce-io__lettuce-core | src/test/java/io/lettuce/core/internal/LettuceStringsTests.java | {
"start": 1011,
"end": 1582
} | class ____ {
@Test
void testToDoubleNan() {
assertThat(LettuceStrings.toDouble("-nan")).isNaN();
assertThat(LettuceStrings.toDouble("nan")).isNaN();
assertThat(LettuceStrings.toDouble("+nan")).isNaN();
}
@Test
void testToDoubleInf() {
assertThat(LettuceStrings.toDouble("-inf")).isEqualTo(Double.NEGATIVE_INFINITY);
assertThat(LettuceStrings.toDouble("inf")).isEqualTo(Double.POSITIVE_INFINITY);
assertThat(LettuceStrings.toDouble("+inf")).isEqualTo(Double.POSITIVE_INFINITY);
}
}
| LettuceStringsTests |
java | quarkusio__quarkus | extensions/amazon-lambda-http/runtime/src/main/java/io/quarkus/amazon/lambda/http/DefaultLambdaAuthenticationRequest.java | {
"start": 311,
"end": 618
} | class ____ extends BaseAuthenticationRequest {
private APIGatewayV2HTTPEvent event;
public DefaultLambdaAuthenticationRequest(APIGatewayV2HTTPEvent event) {
this.event = event;
}
public APIGatewayV2HTTPEvent getEvent() {
return event;
}
}
| DefaultLambdaAuthenticationRequest |
java | alibaba__fastjson | src/test/java/com/alibaba/json/bvtVO/ae/Item.java | {
"start": 43,
"end": 156
} | class ____ implements Area {
public String name;
public String getName() {
return name;
}
}
| Item |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.