This is an automated email from the ASF dual-hosted git repository.
zhangliang pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/shardingsphere.git
The following commit(s) were added to refs/heads/master by this push:
new 4e3d9d6bd6f Use isA instead of instanceOf (#38056)
4e3d9d6bd6f is described below
commit 4e3d9d6bd6f6784e9b254ba1ca5c54dd58730caf
Author: Liang Zhang <[email protected]>
AuthorDate: Mon Feb 16 14:46:07 2026 +0800
Use isA instead of instanceOf (#38056)
* Use isA instead of instanceOf
* Use isA instead of instanceOf
* Use isA instead of instanceOf
* Use isA instead of instanceOf
---
.../PostgreSQLVarcharArrayValueParserTest.java | 4 +-
.../util/ShardingValueTypeConvertUtilsTest.java | 964 +++------------------
.../infra/database/DatabaseTypeEngineTest.java | 6 +-
.../infra/rule/attribute/RuleAttributesTest.java | 4 +-
.../resultset/CircuitBreakerResultSetTest.java | 4 +-
.../CircuitBreakerPreparedStatementTest.java | 10 +-
.../statement/CircuitBreakerStatementTest.java | 4 +-
.../impl/MySQLBinlogUnsignedBigintHandlerTest.java | 6 +-
.../impl/MySQLBinlogUnsignedIntHandlerTest.java | 6 +-
.../MySQLBinlogUnsignedMediumintHandlerTest.java | 6 +-
.../MySQLBinlogUnsignedSmallintHandlerTest.java | 6 +-
.../MySQLBinlogUnsignedTinyintHandlerTest.java | 6 +-
.../YamlCDCJobConfigurationSwapperTest.java | 4 +-
.../cdc/core/importer/CDCImporterTest.java | 6 +-
.../ConsistencyCheckJobItemContextTest.java | 4 +-
.../expression/impl/FunctionConverterTest.java | 4 +-
.../expression/impl/InExpressionConverterTest.java | 4 +-
.../impl/MatchExpressionConverterTest.java | 4 +-
.../impl/TypeCastExpressionConverterTest.java | 4 +-
.../impl/WindowFunctionConverterTest.java | 7 +-
.../segment/from/impl/JoinTableConverterTest.java | 4 +-
.../from/impl/SimpleTableConverterTest.java | 4 +-
.../from/impl/SubqueryTableConverterTest.java | 6 +-
.../impl/AggregationProjectionConverterTest.java | 6 +-
.../impl/ColumnProjectionConverterTest.java | 4 +-
.../type/InsertStatementConverterTest.java | 15 +-
.../type/SelectStatementConverterTest.java | 23 +-
.../type/UpdateStatementConverterTest.java | 8 +-
.../enumerator/jdbc/JDBCDataRowEnumeratorTest.java | 5 +-
.../memory/MemoryDataRowEnumeratorTest.java | 4 +-
.../StandardDatabaseProxyConnectorTest.java | 30 +-
.../ProxyJDBCExecutorCallbackFactoryTest.java | 6 +-
.../local/type/CommitProxyBackendHandlerTest.java | 4 +-
.../admin/FirebirdAdminExecutorCreatorTest.java | 10 +-
.../factory/MySQLShowAdminExecutorFactoryTest.java | 4 +-
...LSelectWithoutFromAdminExecutorFactoryTest.java | 20 +-
.../ConsistencyCheckJobExecutorCallbackTest.java | 6 +-
37 files changed, 252 insertions(+), 970 deletions(-)
diff --git
a/database/protocol/dialect/postgresql/src/test/java/org/apache/shardingsphere/database/protocol/postgresql/packet/command/query/extended/bind/protocol/text/impl/PostgreSQLVarcharArrayValueParserTest.java
b/database/protocol/dialect/postgresql/src/test/java/org/apache/shardingsphere/database/protocol/postgresql/packet/command/query/extended/bind/protocol/text/impl/PostgreSQLVarcharArrayValueParserTest.java
index 459c866796a..8e06b4f8b8e 100644
---
a/database/protocol/dialect/postgresql/src/test/java/org/apache/shardingsphere/database/protocol/postgresql/packet/command/query/extended/bind/protocol/text/impl/PostgreSQLVarcharArrayValueParserTest.java
+++
b/database/protocol/dialect/postgresql/src/test/java/org/apache/shardingsphere/database/protocol/postgresql/packet/command/query/extended/bind/protocol/text/impl/PostgreSQLVarcharArrayValueParserTest.java
@@ -24,9 +24,9 @@ import org.postgresql.util.PGobject;
import java.sql.SQLException;
-import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.isA;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.doThrow;
@@ -45,7 +45,7 @@ class PostgreSQLVarcharArrayValueParserTest {
void assertParseThrowsOnSQLException() {
try (MockedConstruction<PGobject> mocked =
mockConstruction(PGobject.class, (mock, context) -> doThrow(new
SQLException("failed")).when(mock).setValue(anyString()))) {
SQLWrapperException ex = assertThrows(SQLWrapperException.class,
() -> new PostgreSQLVarcharArrayValueParser().parse("bad"));
- assertThat(ex.getCause(), instanceOf(SQLException.class));
+ assertThat(ex.getCause(), isA(SQLException.class));
assertThat(mocked.constructed().size(), is(1));
}
}
diff --git
a/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/util/ShardingValueTypeConvertUtilsTest.java
b/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/util/ShardingValueTypeConvertUtilsTest.java
index 7033daebbb9..ba21d295a06 100644
---
a/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/util/ShardingValueTypeConvertUtilsTest.java
+++
b/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/util/ShardingValueTypeConvertUtilsTest.java
@@ -17,10 +17,14 @@
package org.apache.shardingsphere.sharding.util;
-import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
import java.math.BigDecimal;
import java.math.BigInteger;
+import java.sql.Time;
+import java.sql.Timestamp;
import java.time.Duration;
import java.time.Instant;
import java.time.LocalDate;
@@ -33,853 +37,137 @@ import java.time.ZoneId;
import java.util.Arrays;
import java.util.Collection;
import java.util.Date;
-import java.util.HashSet;
-import java.util.LinkedList;
+import java.util.stream.Stream;
-import static org.hamcrest.CoreMatchers.equalTo;
-import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.isA;
class ShardingValueTypeConvertUtilsTest {
- @Test
- void assertConvertToTargetTypeWhenValueIsNull() {
- assertThat(ShardingValueTypeConvertUtils.convertToTargetType(null,
Integer.class), is(equalTo(null)));
+ @ParameterizedTest(name = "{0}")
+ @MethodSource("convertToTargetTypeArguments")
+ void assertConvertToTargetType(final String name, final Comparable<?>
value, final Class<?> targetType, final Object expected) {
+ assertThat(ShardingValueTypeConvertUtils.convertToTargetType(value,
targetType), is(expected));
}
- @Test
- void assertConvertToTargetTypeWhenTypesMatch() {
- Integer value = 100;
- assertThat(ShardingValueTypeConvertUtils.convertToTargetType(value,
Integer.class), is(equalTo(value)));
- }
-
- @Test
- void assertConvertToIntegerFromLong() {
- Long value = 123L;
- Integer result =
ShardingValueTypeConvertUtils.convertToTargetType(value, Integer.class);
- assertThat(result, is(equalTo(123)));
- assertThat(result, instanceOf(Integer.class));
- }
-
- @Test
- void assertConvertToIntegerFromShort() {
- Short value = 45;
- Integer result =
ShardingValueTypeConvertUtils.convertToTargetType(value, Integer.class);
- assertThat(result, is(equalTo(45)));
- assertThat(result, instanceOf(Integer.class));
- }
-
- @Test
- void assertConvertToIntegerFromByte() {
- Byte value = 10;
- Integer result =
ShardingValueTypeConvertUtils.convertToTargetType(value, Integer.class);
- assertThat(result, is(equalTo(10)));
- assertThat(result, instanceOf(Integer.class));
- }
-
- @Test
- void assertConvertToIntegerFromDouble() {
- Double value = 123.45;
- Integer result =
ShardingValueTypeConvertUtils.convertToTargetType(value, Integer.class);
- assertThat(result, is(equalTo(123)));
- assertThat(result, instanceOf(Integer.class));
- }
-
- @Test
- void assertConvertToIntegerFromFloat() {
- Float value = 67.89f;
- Integer result =
ShardingValueTypeConvertUtils.convertToTargetType(value, Integer.class);
- assertThat(result, is(equalTo(67)));
- assertThat(result, instanceOf(Integer.class));
- }
-
- @Test
- void assertConvertToIntegerFromBigDecimal() {
- BigDecimal value = new BigDecimal("999");
- Integer result =
ShardingValueTypeConvertUtils.convertToTargetType(value, Integer.class);
- assertThat(result, is(equalTo(999)));
- assertThat(result, instanceOf(Integer.class));
- }
-
- @Test
- void assertConvertToIntegerFromBigInteger() {
- BigInteger value = BigInteger.valueOf(777);
- Integer result =
ShardingValueTypeConvertUtils.convertToTargetType(value, Integer.class);
- assertThat(result, is(equalTo(777)));
- assertThat(result, instanceOf(Integer.class));
- }
-
- @Test
- void assertConvertToIntegerFromString() {
- String value = "555";
- Integer result =
ShardingValueTypeConvertUtils.convertToTargetType(value, Integer.class);
- assertThat(result, is(equalTo(555)));
- assertThat(result, instanceOf(Integer.class));
- }
-
- @Test
- void assertConvertToLongFromInteger() {
- Integer value = 123456;
- Long result = ShardingValueTypeConvertUtils.convertToTargetType(value,
Long.class);
- assertThat(result, is(equalTo(123456L)));
- assertThat(result, instanceOf(Long.class));
- }
-
- @Test
- void assertConvertToLongFromShort() {
- Short value = 789;
- Long result = ShardingValueTypeConvertUtils.convertToTargetType(value,
Long.class);
- assertThat(result, is(equalTo(789L)));
- assertThat(result, instanceOf(Long.class));
- }
-
- @Test
- void assertConvertToLongFromDouble() {
- Double value = 12345.67;
- Long result = ShardingValueTypeConvertUtils.convertToTargetType(value,
Long.class);
- assertThat(result, is(equalTo(12345L)));
- assertThat(result, instanceOf(Long.class));
- }
-
- @Test
- void assertConvertToLongFromBigDecimal() {
- BigDecimal value = new BigDecimal("9876543210");
- Long result = ShardingValueTypeConvertUtils.convertToTargetType(value,
Long.class);
- assertThat(result, is(equalTo(9876543210L)));
- assertThat(result, instanceOf(Long.class));
- }
-
- @Test
- void assertConvertToShortFromInteger() {
- Integer value = 123;
- Short result =
ShardingValueTypeConvertUtils.convertToTargetType(value, Short.class);
- assertThat(result, is(equalTo((short) 123)));
- assertThat(result, instanceOf(Short.class));
- }
-
- @Test
- void assertConvertToShortFromLong() {
- Long value = 456L;
- Short result =
ShardingValueTypeConvertUtils.convertToTargetType(value, Short.class);
- assertThat(result, is(equalTo((short) 456)));
- assertThat(result, instanceOf(Short.class));
- }
-
- @Test
- void assertConvertToByteFromInteger() {
- Integer value = 100;
- Byte result = ShardingValueTypeConvertUtils.convertToTargetType(value,
Byte.class);
- assertThat(result, is(equalTo((byte) 100)));
- assertThat(result, instanceOf(Byte.class));
- }
-
- @Test
- void assertConvertToByteFromShort() {
- Short value = 50;
- Byte result = ShardingValueTypeConvertUtils.convertToTargetType(value,
Byte.class);
- assertThat(result, is(equalTo((byte) 50)));
- assertThat(result, instanceOf(Byte.class));
- }
-
- @Test
- void assertConvertToDoubleFromInteger() {
- Integer value = 123;
- Double result =
ShardingValueTypeConvertUtils.convertToTargetType(value, Double.class);
- assertThat(result, is(equalTo(123.0)));
- assertThat(result, instanceOf(Double.class));
- }
-
- @Test
- void assertConvertToDoubleFromLong() {
- Long value = 456L;
- Double result =
ShardingValueTypeConvertUtils.convertToTargetType(value, Double.class);
- assertThat(result, is(equalTo(456.0)));
- assertThat(result, instanceOf(Double.class));
- }
-
- @Test
- void assertConvertToDoubleFromFloat() {
- Float value = 78.9f;
- Double result =
ShardingValueTypeConvertUtils.convertToTargetType(value, Double.class);
- assertThat(result, is(equalTo(78.9000015258789)));
- assertThat(result, instanceOf(Double.class));
- }
-
- @Test
- void assertConvertToDoubleFromBigDecimal() {
- BigDecimal value = new BigDecimal("123.456");
- Double result =
ShardingValueTypeConvertUtils.convertToTargetType(value, Double.class);
- assertThat(result, is(equalTo(123.456)));
- assertThat(result, instanceOf(Double.class));
- }
-
- @Test
- void assertConvertToFloatFromInteger() {
- Integer value = 234;
- Float result =
ShardingValueTypeConvertUtils.convertToTargetType(value, Float.class);
- assertThat(result, is(equalTo(234.0f)));
- assertThat(result, instanceOf(Float.class));
- }
-
- @Test
- void assertConvertToFloatFromDouble() {
- Double value = 56.78;
- Float result =
ShardingValueTypeConvertUtils.convertToTargetType(value, Float.class);
- assertThat(result, is(equalTo(56.78f)));
- assertThat(result, instanceOf(Float.class));
- }
-
- @Test
- void assertConvertToBigDecimalFromInteger() {
- Integer value = 999;
- BigDecimal result =
ShardingValueTypeConvertUtils.convertToTargetType(value, BigDecimal.class);
- assertThat(result.compareTo(new BigDecimal("999")), is(equalTo(0)));
- assertThat(result, instanceOf(BigDecimal.class));
- }
-
- @Test
- void assertConvertToBigDecimalFromLong() {
- Long value = 888L;
- BigDecimal result =
ShardingValueTypeConvertUtils.convertToTargetType(value, BigDecimal.class);
- assertThat(result.compareTo(new BigDecimal("888")), is(equalTo(0)));
- assertThat(result, instanceOf(BigDecimal.class));
- }
-
- @Test
- void assertConvertToBigDecimalFromDouble() {
- Double value = 123.456;
- BigDecimal result =
ShardingValueTypeConvertUtils.convertToTargetType(value, BigDecimal.class);
- assertThat(result, is(equalTo(BigDecimal.valueOf(123.456))));
- assertThat(result, instanceOf(BigDecimal.class));
- }
-
- @Test
- void assertConvertToBigDecimalFromBigInteger() {
- BigInteger value = BigInteger.valueOf(12345);
- BigDecimal result =
ShardingValueTypeConvertUtils.convertToTargetType(value, BigDecimal.class);
- assertThat(result, is(equalTo(new BigDecimal("12345"))));
- assertThat(result, instanceOf(BigDecimal.class));
- }
-
- @Test
- void assertConvertToBigDecimalFromString() {
- String value = "999.888";
- BigDecimal result =
ShardingValueTypeConvertUtils.convertToTargetType(value, BigDecimal.class);
- assertThat(result, is(equalTo(new BigDecimal("999.888"))));
- assertThat(result, instanceOf(BigDecimal.class));
- }
-
- @Test
- void assertConvertToBigIntegerFromInteger() {
- Integer value = 777;
- BigInteger result =
ShardingValueTypeConvertUtils.convertToTargetType(value, BigInteger.class);
- assertThat(result, is(equalTo(BigInteger.valueOf(777))));
- assertThat(result, instanceOf(BigInteger.class));
- }
-
- @Test
- void assertConvertToBigIntegerFromLong() {
- Long value = 666L;
- BigInteger result =
ShardingValueTypeConvertUtils.convertToTargetType(value, BigInteger.class);
- assertThat(result, is(equalTo(BigInteger.valueOf(666))));
- assertThat(result, instanceOf(BigInteger.class));
- }
-
- @Test
- void assertConvertToBigIntegerFromBigDecimal() {
- BigDecimal value = new BigDecimal("555");
- BigInteger result =
ShardingValueTypeConvertUtils.convertToTargetType(value, BigInteger.class);
- assertThat(result, is(equalTo(BigInteger.valueOf(555))));
- assertThat(result, instanceOf(BigInteger.class));
- }
-
- @Test
- void assertConvertToStringFromInteger() {
- Integer value = 123;
- String result =
ShardingValueTypeConvertUtils.convertToTargetType(value, String.class);
- assertThat(result, is(equalTo("123")));
- assertThat(result, instanceOf(String.class));
- }
-
- @Test
- void assertConvertToStringFromLong() {
- Long value = 456L;
- String result =
ShardingValueTypeConvertUtils.convertToTargetType(value, String.class);
- assertThat(result, is(equalTo("456")));
- assertThat(result, instanceOf(String.class));
- }
-
- @Test
- void assertConvertToStringFromDouble() {
- Double value = 78.9;
- String result =
ShardingValueTypeConvertUtils.convertToTargetType(value, String.class);
- assertThat(result, is(equalTo("78.9")));
- assertThat(result, instanceOf(String.class));
- }
-
- @Test
- void assertConvertToStringFromBigDecimal() {
- BigDecimal value = new BigDecimal("123.456");
- String result =
ShardingValueTypeConvertUtils.convertToTargetType(value, String.class);
- assertThat(result, is(equalTo("123.456")));
- assertThat(result, instanceOf(String.class));
- }
-
- @Test
- void assertConvertCollectionTypeToIntegers() {
- Collection<Comparable<?>> source = Arrays.asList(1L, 2L, 3L, 4L);
- Collection<Comparable<?>> result =
ShardingValueTypeConvertUtils.convertCollectionType(source, Integer.class);
- assertThat(result.size(), is(4));
- for (Comparable<?> value : result) {
- assertThat(value, instanceOf(Integer.class));
+ @ParameterizedTest(name = "{0}")
+ @MethodSource("convertCollectionTypeArguments")
+ void assertConvertCollectionType(final String name, final
Collection<Comparable<?>> source, final Class<?> targetType, final int
expectedSize, final Class<?> expectedElementType) {
+ Collection<Comparable<?>> actual =
ShardingValueTypeConvertUtils.convertCollectionType(source, targetType);
+ assertThat(actual.size(), is(expectedSize));
+ for (Comparable<?> each : actual) {
+ assertThat(each, isA(expectedElementType));
}
}
- @Test
- void assertConvertCollectionTypeToLongs() {
- Collection<Comparable<?>> source = Arrays.asList(100, 200, 300);
- Collection<Comparable<?>> result =
ShardingValueTypeConvertUtils.convertCollectionType(source, Long.class);
- assertThat(result.size(), is(3));
- for (Comparable<?> value : result) {
- assertThat(value, instanceOf(Long.class));
- }
- }
-
- @Test
- void assertConvertCollectionTypeToDoubles() {
- Collection<Comparable<?>> source = Arrays.asList(10, 20, 30);
- Collection<Comparable<?>> result =
ShardingValueTypeConvertUtils.convertCollectionType(source, Double.class);
- assertThat(result.size(), is(3));
- for (Comparable<?> value : result) {
- assertThat(value, instanceOf(Double.class));
- }
- }
-
- @Test
- void assertConvertCollectionTypeToStrings() {
- Collection<Comparable<?>> source = Arrays.asList(123, 456, 789);
- Collection<Comparable<?>> result =
ShardingValueTypeConvertUtils.convertCollectionType(source, String.class);
- assertThat(result.size(), is(3));
- assertThat(new LinkedList<>(result).get(0), is(equalTo("123")));
- assertThat(new LinkedList<>(result).get(1), is(equalTo("456")));
- assertThat(new LinkedList<>(result).get(2), is(equalTo("789")));
- }
-
- @Test
- void assertConvertCollectionTypeWithMixedNumericTypes() {
- Collection<Comparable<?>> source = Arrays.asList(1, 2L, 3.0, 4.0f);
- Collection<Comparable<?>> result =
ShardingValueTypeConvertUtils.convertCollectionType(source, Integer.class);
- assertThat(result.size(), is(4));
- for (Comparable<?> value : result) {
- assertThat(value, instanceOf(Integer.class));
- }
- }
-
- @Test
- void assertConvertCollectionTypeEmptyCollection() {
- Collection<Comparable<?>> source = new HashSet<>();
- Collection<Comparable<?>> result =
ShardingValueTypeConvertUtils.convertCollectionType(source, Integer.class);
- assertThat(result.isEmpty(), is(true));
- }
-
- @Test
- void assertConvertCollectionTypeToBigDecimal() {
- Collection<Comparable<?>> source = Arrays.asList(100, 200L, 300.5);
- Collection<Comparable<?>> result =
ShardingValueTypeConvertUtils.convertCollectionType(source, BigDecimal.class);
- assertThat(result.size(), is(3));
- for (Comparable<?> value : result) {
- assertThat(value, instanceOf(BigDecimal.class));
- }
- }
-
- @Test
- void assertConvertCollectionTypeToBigInteger() {
- Collection<Comparable<?>> source = Arrays.asList(100, 200L, 300);
- Collection<Comparable<?>> result =
ShardingValueTypeConvertUtils.convertCollectionType(source, BigInteger.class);
- assertThat(result.size(), is(3));
- for (Comparable<?> value : result) {
- assertThat(value, instanceOf(BigInteger.class));
- }
- }
-
- @Test
- void assertConvertToBooleanFromInteger() {
- Integer value = 1;
- Boolean result =
ShardingValueTypeConvertUtils.convertToTargetType(value, Boolean.class);
- assertThat(result, is(equalTo(true)));
- assertThat(result, instanceOf(Boolean.class));
- }
-
- @Test
- void assertConvertToBooleanFromIntegerZero() {
- Integer value = 0;
- Boolean result =
ShardingValueTypeConvertUtils.convertToTargetType(value, Boolean.class);
- assertThat(result, is(equalTo(false)));
- assertThat(result, instanceOf(Boolean.class));
- }
-
- @Test
- void assertConvertToBooleanFromStringTrue() {
- String value = "true";
- Boolean result =
ShardingValueTypeConvertUtils.convertToTargetType(value, Boolean.class);
- assertThat(result, is(equalTo(true)));
- assertThat(result, instanceOf(Boolean.class));
- }
-
- @Test
- void assertConvertToBooleanFromStringFalse() {
- String value = "false";
- Boolean result =
ShardingValueTypeConvertUtils.convertToTargetType(value, Boolean.class);
- assertThat(result, is(equalTo(false)));
- assertThat(result, instanceOf(Boolean.class));
- }
-
- @Test
- void assertConvertToBooleanFromStringOne() {
- String value = "1";
- Boolean result =
ShardingValueTypeConvertUtils.convertToTargetType(value, Boolean.class);
- assertThat(result, is(equalTo(true)));
- assertThat(result, instanceOf(Boolean.class));
- }
-
- @Test
- void assertConvertToBooleanFromStringZero() {
- String value = "0";
- Boolean result =
ShardingValueTypeConvertUtils.convertToTargetType(value, Boolean.class);
- assertThat(result, is(equalTo(false)));
- assertThat(result, instanceOf(Boolean.class));
- }
-
- @Test
- void assertConvertToCharacterFromInteger() {
- Integer value = 65;
- Character result =
ShardingValueTypeConvertUtils.convertToTargetType(value, Character.class);
- assertThat(result, is(equalTo('A')));
- assertThat(result, instanceOf(Character.class));
- }
-
- @Test
- void assertConvertToCharacterFromString() {
- String value = "X";
- Character result =
ShardingValueTypeConvertUtils.convertToTargetType(value, Character.class);
- assertThat(result, is(equalTo('X')));
- assertThat(result, instanceOf(Character.class));
- }
-
- @Test
- void assertConvertToCharacterFromEmptyString() {
- String value = "";
- Character result =
ShardingValueTypeConvertUtils.convertToTargetType(value, Character.class);
- assertThat(result, is(equalTo('\0')));
- assertThat(result, instanceOf(Character.class));
- }
-
- @Test
- void assertConvertToDateFromLong() {
- Long value = 1704067200000L;
- Date result = ShardingValueTypeConvertUtils.convertToTargetType(value,
Date.class);
- assertThat(result, instanceOf(Date.class));
- assertThat(result.getTime(), is(equalTo(value)));
- }
-
- @Test
- void assertConvertToDateFromLocalDateTime() {
- LocalDateTime value = LocalDateTime.of(2024, 1, 1, 0, 0);
- Date result = ShardingValueTypeConvertUtils.convertToTargetType(value,
Date.class);
- assertThat(result, instanceOf(Date.class));
- }
-
- @Test
- void assertConvertToDateFromLocalDate() {
- LocalDate value = LocalDate.of(2024, 1, 1);
- Date result = ShardingValueTypeConvertUtils.convertToTargetType(value,
Date.class);
- assertThat(result, instanceOf(Date.class));
- }
-
- @Test
- void assertConvertToDateFromInstant() {
- Instant value = Instant.parse("2024-01-01T00:00:00Z");
- Date result = ShardingValueTypeConvertUtils.convertToTargetType(value,
Date.class);
- assertThat(result, instanceOf(Date.class));
- assertThat(result.toInstant(), is(equalTo(value)));
- }
-
- @Test
- void assertConvertToSqlDateFromLocalDate() {
- LocalDate value = LocalDate.of(2024, 1, 1);
- java.sql.Date result =
ShardingValueTypeConvertUtils.convertToTargetType(value, java.sql.Date.class);
- assertThat(result, instanceOf(java.sql.Date.class));
- assertThat(result.toLocalDate(), is(equalTo(value)));
- }
-
- @Test
- void assertConvertToSqlDateFromDate() {
- Date value = new Date();
- java.sql.Date result =
ShardingValueTypeConvertUtils.convertToTargetType(value, java.sql.Date.class);
- assertThat(result, instanceOf(java.sql.Date.class));
- }
-
- @Test
- void assertConvertToSqlTimeFromLocalTime() {
- LocalTime value = LocalTime.of(12, 30, 45);
- java.sql.Time result =
ShardingValueTypeConvertUtils.convertToTargetType(value, java.sql.Time.class);
- assertThat(result, instanceOf(java.sql.Time.class));
- assertThat(result.toLocalTime(), is(equalTo(value)));
- }
-
- @Test
- void assertConvertToTimestampFromLocalDateTime() {
- LocalDateTime value = LocalDateTime.of(2024, 1, 1, 12, 30, 45);
- java.sql.Timestamp result =
ShardingValueTypeConvertUtils.convertToTargetType(value,
java.sql.Timestamp.class);
- assertThat(result, instanceOf(java.sql.Timestamp.class));
- assertThat(result.toLocalDateTime(), is(equalTo(value)));
- }
-
- @Test
- void assertConvertToTimestampFromInstant() {
- Instant value = Instant.parse("2024-01-01T12:30:45Z");
- java.sql.Timestamp result =
ShardingValueTypeConvertUtils.convertToTargetType(value,
java.sql.Timestamp.class);
- assertThat(result, instanceOf(java.sql.Timestamp.class));
- }
-
- @Test
- void assertConvertToLocalDateFromDate() {
- Date value = new Date();
- LocalDate result =
ShardingValueTypeConvertUtils.convertToTargetType(value, LocalDate.class);
- assertThat(result, instanceOf(LocalDate.class));
- }
-
- @Test
- void assertConvertToLocalDateFromLocalDateTime() {
- LocalDateTime value = LocalDateTime.of(2024, 1, 1, 12, 30, 45);
- LocalDate result =
ShardingValueTypeConvertUtils.convertToTargetType(value, LocalDate.class);
- assertThat(result, is(equalTo(LocalDate.of(2024, 1, 1))));
- assertThat(result, instanceOf(LocalDate.class));
- }
-
- @Test
- void assertConvertToLocalDateFromSqlDate() {
- java.sql.Date value = java.sql.Date.valueOf("2024-01-01");
- LocalDate result =
ShardingValueTypeConvertUtils.convertToTargetType(value, LocalDate.class);
- assertThat(result, is(equalTo(LocalDate.of(2024, 1, 1))));
- assertThat(result, instanceOf(LocalDate.class));
- }
-
- @Test
- void assertConvertToLocalTimeFromSqlTime() {
- java.sql.Time value = java.sql.Time.valueOf("12:30:45");
- LocalTime result =
ShardingValueTypeConvertUtils.convertToTargetType(value, LocalTime.class);
- assertThat(result, is(equalTo(LocalTime.of(12, 30, 45))));
- assertThat(result, instanceOf(LocalTime.class));
- }
-
- @Test
- void assertConvertToLocalTimeFromLocalDateTime() {
- LocalDateTime value = LocalDateTime.of(2024, 1, 1, 12, 30, 45);
- LocalTime result =
ShardingValueTypeConvertUtils.convertToTargetType(value, LocalTime.class);
- assertThat(result, is(equalTo(LocalTime.of(12, 30, 45))));
- assertThat(result, instanceOf(LocalTime.class));
- }
-
- @Test
- void assertConvertToLocalDateTimeFromDate() {
- Date value = new Date();
- LocalDateTime result =
ShardingValueTypeConvertUtils.convertToTargetType(value, LocalDateTime.class);
- assertThat(result, instanceOf(LocalDateTime.class));
- }
-
- @Test
- void assertConvertToLocalDateTimeFromLocalDate() {
- LocalDate value = LocalDate.of(2024, 1, 1);
- LocalDateTime result =
ShardingValueTypeConvertUtils.convertToTargetType(value, LocalDateTime.class);
- assertThat(result, is(equalTo(LocalDateTime.of(2024, 1, 1, 0, 0))));
- assertThat(result, instanceOf(LocalDateTime.class));
- }
-
- @Test
- void assertConvertToLocalDateTimeFromTimestamp() {
- java.sql.Timestamp value = java.sql.Timestamp.valueOf("2024-01-01
12:30:45");
- LocalDateTime result =
ShardingValueTypeConvertUtils.convertToTargetType(value, LocalDateTime.class);
- assertThat(result, is(equalTo(LocalDateTime.of(2024, 1, 1, 12, 30,
45))));
- assertThat(result, instanceOf(LocalDateTime.class));
- }
-
- @Test
- void assertConvertToInstantFromDate() {
- Date value = new Date();
- Instant result =
ShardingValueTypeConvertUtils.convertToTargetType(value, Instant.class);
- assertThat(result, is(equalTo(value.toInstant())));
- assertThat(result, instanceOf(Instant.class));
- }
-
- @Test
- void assertConvertToInstantFromLong() {
- Long value = 1704067200000L;
- Instant result =
ShardingValueTypeConvertUtils.convertToTargetType(value, Instant.class);
- assertThat(result, is(equalTo(Instant.ofEpochMilli(value))));
- assertThat(result, instanceOf(Instant.class));
- }
-
- @Test
- void assertConvertToYearFromInteger() {
- Integer value = 2024;
- Year result = ShardingValueTypeConvertUtils.convertToTargetType(value,
Year.class);
- assertThat(result, is(equalTo(Year.of(2024))));
- assertThat(result, instanceOf(Year.class));
- }
-
- @Test
- void assertConvertToYearFromLocalDate() {
- LocalDate value = LocalDate.of(2024, 6, 15);
- Year result = ShardingValueTypeConvertUtils.convertToTargetType(value,
Year.class);
- assertThat(result, is(equalTo(Year.of(2024))));
- assertThat(result, instanceOf(Year.class));
- }
-
- @Test
- void assertConvertToYearMonthFromLocalDate() {
- LocalDate value = LocalDate.of(2024, 6, 15);
- YearMonth result =
ShardingValueTypeConvertUtils.convertToTargetType(value, YearMonth.class);
- assertThat(result, is(equalTo(YearMonth.of(2024, 6))));
- assertThat(result, instanceOf(YearMonth.class));
- }
-
- @Test
- void assertConvertToMonthDayFromLocalDate() {
- LocalDate value = LocalDate.of(2024, 6, 15);
- MonthDay result =
ShardingValueTypeConvertUtils.convertToTargetType(value, MonthDay.class);
- assertThat(result, is(equalTo(MonthDay.of(6, 15))));
- assertThat(result, instanceOf(MonthDay.class));
- }
-
- @Test
- void assertConvertToDurationFromLong() {
- Long value = 5000L;
- Duration result =
ShardingValueTypeConvertUtils.convertToTargetType(value, Duration.class);
- assertThat(result, is(equalTo(Duration.ofMillis(5000L))));
- assertThat(result, instanceOf(Duration.class));
- }
-
- @Test
- void assertConvertToDurationFromString() {
- String value = "PT60S";
- Duration result =
ShardingValueTypeConvertUtils.convertToTargetType(value, Duration.class);
- assertThat(result, is(equalTo(Duration.ofSeconds(60))));
- assertThat(result, instanceOf(Duration.class));
- }
-
- @Test
- void assertConvertCollectionTypeToLocalDates() {
- Collection<Comparable<?>> source = Arrays.asList(
- LocalDate.of(2024, 1, 1),
- LocalDate.of(2024, 2, 1),
- LocalDate.of(2024, 3, 1));
- Collection<Comparable<?>> result =
ShardingValueTypeConvertUtils.convertCollectionType(source, Year.class);
- assertThat(result.size(), is(3));
- for (Comparable<?> value : result) {
- assertThat(value, instanceOf(Year.class));
- }
- }
-
- @Test
- void assertConvertCollectionTypeToBooleans() {
- Collection<Comparable<?>> source = Arrays.asList(1, 0, 2, "true");
- Collection<Comparable<?>> result =
ShardingValueTypeConvertUtils.convertCollectionType(source, Boolean.class);
- assertThat(result.size(), is(4));
- for (Comparable<?> value : result) {
- assertThat(value, instanceOf(Boolean.class));
- }
- }
-
- @Test
- void assertConvertCollectionTypeToDurations() {
- Collection<Comparable<?>> source = Arrays.asList(1000L, 2000L, 3000L);
- Collection<Comparable<?>> result =
ShardingValueTypeConvertUtils.convertCollectionType(source, Duration.class);
- assertThat(result.size(), is(3));
- for (Comparable<?> value : result) {
- assertThat(value, instanceOf(Duration.class));
- }
- }
-
- // ========== String to Type Conversion Tests (non-duplicate) ==========
-
- @Test
- void assertConvertToLongFromString() {
- String value = "123456789";
- Long result = ShardingValueTypeConvertUtils.convertToTargetType(value,
Long.class);
- assertThat(result, is(equalTo(123456789L)));
- assertThat(result, instanceOf(Long.class));
- }
-
- @Test
- void assertConvertToShortFromString() {
- String value = "123";
- Short result =
ShardingValueTypeConvertUtils.convertToTargetType(value, Short.class);
- assertThat(result, is(equalTo((short) 123)));
- assertThat(result, instanceOf(Short.class));
- }
-
- @Test
- void assertConvertToByteFromString() {
- String value = "100";
- Byte result = ShardingValueTypeConvertUtils.convertToTargetType(value,
Byte.class);
- assertThat(result, is(equalTo((byte) 100)));
- assertThat(result, instanceOf(Byte.class));
- }
-
- @Test
- void assertConvertToDoubleFromString() {
- String value = "123.456";
- Double result =
ShardingValueTypeConvertUtils.convertToTargetType(value, Double.class);
- assertThat(result, is(equalTo(123.456)));
- assertThat(result, instanceOf(Double.class));
- }
-
- @Test
- void assertConvertToFloatFromString() {
- String value = "78.9";
- Float result =
ShardingValueTypeConvertUtils.convertToTargetType(value, Float.class);
- assertThat(result, is(equalTo(78.9f)));
- assertThat(result, instanceOf(Float.class));
- }
-
- @Test
- void assertConvertToBigIntegerFromString() {
- String value = "123456789";
- BigInteger result =
ShardingValueTypeConvertUtils.convertToTargetType(value, BigInteger.class);
- assertThat(result, is(equalTo(BigInteger.valueOf(123456789))));
- assertThat(result, instanceOf(BigInteger.class));
- }
-
- @Test
- void assertConvertToBooleanFromStringUpperCase() {
- String value = "TRUE";
- Boolean result =
ShardingValueTypeConvertUtils.convertToTargetType(value, Boolean.class);
- assertThat(result, is(equalTo(true)));
- assertThat(result, instanceOf(Boolean.class));
- }
-
- @Test
- void assertConvertToDateFromStringLocalDate() {
- String value = "2024-08-05";
- Date result = ShardingValueTypeConvertUtils.convertToTargetType(value,
Date.class);
- assertThat(result, instanceOf(Date.class));
- }
-
- @Test
- void assertConvertToDateFromStringLocalDateTime() {
- String value = "2024-08-05T12:30:45";
- Date result = ShardingValueTypeConvertUtils.convertToTargetType(value,
Date.class);
- assertThat(result, instanceOf(Date.class));
- }
-
- @Test
- void assertConvertToDateFromStringInstant() {
- String value = "2024-08-05T12:30:45Z";
- Date result = ShardingValueTypeConvertUtils.convertToTargetType(value,
Date.class);
- assertThat(result, instanceOf(Date.class));
- }
-
- @Test
- void assertConvertToSqlDateFromStringLocalDate() {
- String value = "2024-08-05";
- java.sql.Date result =
ShardingValueTypeConvertUtils.convertToTargetType(value, java.sql.Date.class);
- assertThat(result, instanceOf(java.sql.Date.class));
- assertThat(result.toLocalDate(), is(equalTo(LocalDate.of(2024, 8,
5))));
- }
-
- @Test
- void assertConvertToSqlTimeFromString() {
- String value = "12:30:45";
- java.sql.Time result =
ShardingValueTypeConvertUtils.convertToTargetType(value, java.sql.Time.class);
- assertThat(result, instanceOf(java.sql.Time.class));
- assertThat(result.toLocalTime(), is(equalTo(LocalTime.of(12, 30,
45))));
- }
-
- @Test
- void assertConvertToTimestampFromString() {
- String value = "2024-08-05T12:30:45";
- java.sql.Timestamp result =
ShardingValueTypeConvertUtils.convertToTargetType(value,
java.sql.Timestamp.class);
- assertThat(result, instanceOf(java.sql.Timestamp.class));
- }
-
- @Test
- void assertConvertToLocalDateFromString() {
- String value = "2024-08-05";
- LocalDate result =
ShardingValueTypeConvertUtils.convertToTargetType(value, LocalDate.class);
- assertThat(result, is(equalTo(LocalDate.of(2024, 8, 5))));
- assertThat(result, instanceOf(LocalDate.class));
- }
-
- @Test
- void assertConvertToLocalDateFromStringDateTime() {
- String value = "2024-08-05T12:30:45";
- LocalDate result =
ShardingValueTypeConvertUtils.convertToTargetType(value, LocalDate.class);
- assertThat(result, is(equalTo(LocalDate.of(2024, 8, 5))));
- assertThat(result, instanceOf(LocalDate.class));
- }
-
- @Test
- void assertConvertToLocalTimeFromString() {
- String value = "12:30:45";
- LocalTime result =
ShardingValueTypeConvertUtils.convertToTargetType(value, LocalTime.class);
- assertThat(result, is(equalTo(LocalTime.of(12, 30, 45))));
- assertThat(result, instanceOf(LocalTime.class));
- }
-
- @Test
- void assertConvertToLocalDateTimeFromString() {
- String value = "2024-08-05T12:30:45";
- LocalDateTime result =
ShardingValueTypeConvertUtils.convertToTargetType(value, LocalDateTime.class);
- assertThat(result, is(equalTo(LocalDateTime.of(2024, 8, 5, 12, 30,
45))));
- assertThat(result, instanceOf(LocalDateTime.class));
- }
-
- @Test
- void assertConvertToInstantFromString() {
- String value = "2024-08-05T12:30:45Z";
- Instant result =
ShardingValueTypeConvertUtils.convertToTargetType(value, Instant.class);
- assertThat(result, instanceOf(Instant.class));
- }
-
- @Test
- void assertConvertToInstantFromStringLocalDate() {
- String value = "2024-08-05";
- Instant result =
ShardingValueTypeConvertUtils.convertToTargetType(value, Instant.class);
- assertThat(result, instanceOf(Instant.class));
- assertThat(result.atZone(ZoneId.systemDefault()).toLocalDate(),
is(equalTo(LocalDate.of(2024, 8, 5))));
- }
-
- @Test
- void assertConvertToYearFromString() {
- String value = "2024";
- Year result = ShardingValueTypeConvertUtils.convertToTargetType(value,
Year.class);
- assertThat(result, is(equalTo(Year.of(2024))));
- assertThat(result, instanceOf(Year.class));
- }
-
- @Test
- void assertConvertToYearMonthFromString() {
- String value = "2024-08";
- YearMonth result =
ShardingValueTypeConvertUtils.convertToTargetType(value, YearMonth.class);
- assertThat(result, is(equalTo(YearMonth.of(2024, 8))));
- assertThat(result, instanceOf(YearMonth.class));
- }
-
- @Test
- void assertConvertToMonthDayFromString() {
- String value = "--08-05";
- MonthDay result =
ShardingValueTypeConvertUtils.convertToTargetType(value, MonthDay.class);
- assertThat(result, is(equalTo(MonthDay.of(8, 5))));
- assertThat(result, instanceOf(MonthDay.class));
- }
-
- @Test
- void assertConvertToDurationFromStringSeconds() {
- String value = "PT60S";
- Duration result =
ShardingValueTypeConvertUtils.convertToTargetType(value, Duration.class);
- assertThat(result, is(equalTo(Duration.ofSeconds(60))));
- assertThat(result, instanceOf(Duration.class));
+ private static Stream<Arguments> convertToTargetTypeArguments() {
+ return Stream.of(
+ Arguments.of("TargetType <- null", null, Integer.class, null),
+ Arguments.of("TargetType <- types match", 100, Integer.class,
100),
+ Arguments.of("Integer <- Long", 123L, Integer.class, 123),
+ Arguments.of("Integer <- Short", (short) 45, Integer.class,
45),
+ Arguments.of("Integer <- Byte", (byte) 10, Integer.class, 10),
+ Arguments.of("Integer <- Double", 123.45D, Integer.class, 123),
+ Arguments.of("Integer <- Float", 67.89F, Integer.class, 67),
+ Arguments.of("Integer <- BigDecimal", new BigDecimal("999"),
Integer.class, 999),
+ Arguments.of("Integer <- BigInteger", BigInteger.valueOf(777),
Integer.class, 777),
+ Arguments.of("Integer <- String", "555", Integer.class, 555),
+ Arguments.of("Long <- Integer", 123456, Long.class, 123456L),
+ Arguments.of("Long <- Short", (short) 789, Long.class, 789L),
+ Arguments.of("Long <- Double", 12345.67D, Long.class, 12345L),
+ Arguments.of("Long <- BigDecimal", new
BigDecimal("9876543210"), Long.class, 9876543210L),
+ Arguments.of("Long <- String", "123456789", Long.class,
123456789L),
+ Arguments.of("Short <- Integer", 123, Short.class, (short)
123),
+ Arguments.of("Short <- Long", 456L, Short.class, (short) 456),
+ Arguments.of("Short <- String", "123", Short.class, (short)
123),
+ Arguments.of("Byte <- Integer", 100, Byte.class, (byte) 100),
+ Arguments.of("Byte <- Short", (short) 50, Byte.class, (byte)
50),
+ Arguments.of("Byte <- String", "100", Byte.class, (byte) 100),
+ Arguments.of("Double <- Integer", 123, Double.class, 123.0D),
+ Arguments.of("Double <- Long", 456L, Double.class, 456.0D),
+ Arguments.of("Double <- Float", 78.9F, Double.class,
78.9000015258789D),
+ Arguments.of("Double <- BigDecimal", new
BigDecimal("123.456"), Double.class, 123.456D),
+ Arguments.of("Double <- String", "123.456", Double.class,
123.456D),
+ Arguments.of("Float <- Integer", 234, Float.class, 234.0F),
+ Arguments.of("Float <- Double", 56.78D, Float.class, 56.78F),
+ Arguments.of("Float <- String", "78.9", Float.class, 78.9F),
+ Arguments.of("BigDecimal <- Integer", 999, BigDecimal.class,
BigDecimal.valueOf(999D)),
+ Arguments.of("BigDecimal <- Long", 888L, BigDecimal.class,
BigDecimal.valueOf(888D)),
+ Arguments.of("BigDecimal <- Double", 123.456D,
BigDecimal.class, BigDecimal.valueOf(123.456D)),
+ Arguments.of("BigDecimal <- BigInteger",
BigInteger.valueOf(12345), BigDecimal.class, new BigDecimal("12345")),
+ Arguments.of("BigDecimal <- String", "999.888",
BigDecimal.class, new BigDecimal("999.888")),
+ Arguments.of("BigInteger <- Integer", 777, BigInteger.class,
BigInteger.valueOf(777)),
+ Arguments.of("BigInteger <- Long", 666L, BigInteger.class,
BigInteger.valueOf(666)),
+ Arguments.of("BigInteger <- BigDecimal", new
BigDecimal("555"), BigInteger.class, BigInteger.valueOf(555)),
+ Arguments.of("BigInteger <- String", "123456789",
BigInteger.class, BigInteger.valueOf(123456789L)),
+ Arguments.of("String <- Integer", 123, String.class, "123"),
+ Arguments.of("String <- Long", 456L, String.class, "456"),
+ Arguments.of("String <- Double", 78.9D, String.class, "78.9"),
+ Arguments.of("String <- BigDecimal", new
BigDecimal("123.456"), String.class, "123.456"),
+ Arguments.of("Boolean <- Integer(1)", 1, Boolean.class, true),
+ Arguments.of("Boolean <- Integer(0)", 0, Boolean.class, false),
+ Arguments.of("Boolean <- String(true)", "true", Boolean.class,
true),
+ Arguments.of("Boolean <- String(false)", "false",
Boolean.class, false),
+ Arguments.of("Boolean <- String(1)", "1", Boolean.class, true),
+ Arguments.of("Boolean <- String(0)", "0", Boolean.class,
false),
+ Arguments.of("Boolean <- String(TRUE)", "TRUE", Boolean.class,
true),
+ Arguments.of("Character <- Integer", 65, Character.class, 'A'),
+ Arguments.of("Character <- String", "X", Character.class, 'X'),
+ Arguments.of("Character <- EmptyString", "", Character.class,
'\0'),
+ Arguments.of("Date <- Long", 1704067200000L, Date.class, new
Date(1704067200000L)),
+ Arguments.of("Date <- LocalDateTime", LocalDateTime.of(2024,
1, 1, 0, 0), Date.class, Date.from(LocalDateTime.of(2024, 1, 1, 0,
0).atZone(ZoneId.systemDefault()).toInstant())),
+ Arguments.of("Date <- LocalDate", LocalDate.of(2024, 1, 1),
Date.class, Date.from(LocalDate.of(2024, 1,
1).atStartOfDay(ZoneId.systemDefault()).toInstant())),
+ Arguments.of("Date <- Instant",
Instant.parse("2024-01-01T00:00:00Z"), Date.class,
Date.from(Instant.parse("2024-01-01T00:00:00Z"))),
+ Arguments.of("Date <- String(LocalDate)", "2024-08-05",
Date.class, Date.from(LocalDate.of(2024, 8,
5).atStartOfDay(ZoneId.systemDefault()).toInstant())),
+ Arguments.of("Date <- String(LocalDateTime)",
"2024-08-05T12:30:45", Date.class, Date.from(LocalDateTime.of(2024, 8, 5, 12,
30, 45).atZone(ZoneId.systemDefault()).toInstant())),
+ Arguments.of("Date <- String(Instant)",
"2024-08-05T12:30:45Z", Date.class,
Date.from(Instant.parse("2024-08-05T12:30:45Z"))),
+ Arguments.of("SqlDate <- LocalDate", LocalDate.of(2024, 1, 1),
java.sql.Date.class, java.sql.Date.valueOf(LocalDate.of(2024, 1, 1))),
+ Arguments.of("SqlDate <- Date", new Date(1704067200000L),
java.sql.Date.class, new java.sql.Date(new Date(1704067200000L).getTime())),
+ Arguments.of("SqlDate <- String(LocalDate)", "2024-08-05",
java.sql.Date.class, java.sql.Date.valueOf(LocalDate.of(2024, 8, 5))),
+ Arguments.of("SqlTime <- LocalTime", LocalTime.of(12, 30, 45),
Time.class, Time.valueOf(LocalTime.of(12, 30, 45))),
+ Arguments.of("SqlTime <- String", "12:30:45", Time.class,
Time.valueOf(LocalTime.of(12, 30, 45))),
+ Arguments.of("Timestamp <- LocalDateTime",
LocalDateTime.of(2024, 1, 1, 12, 30, 45), Timestamp.class,
Timestamp.valueOf(LocalDateTime.of(2024, 1, 1, 12, 30, 45))),
+ Arguments.of("Timestamp <- Instant",
Instant.parse("2024-01-01T12:30:45Z"), Timestamp.class,
Timestamp.from(Instant.parse("2024-01-01T12:30:45Z"))),
+ Arguments.of("Timestamp <- String", "2024-08-05T12:30:45",
Timestamp.class, Timestamp.from(LocalDateTime.of(2024, 8, 5, 12, 30,
45).atZone(ZoneId.systemDefault()).toInstant())),
+ Arguments.of("Instant <- Date", new Date(1704067200000L),
Instant.class, new Date(1704067200000L).toInstant()),
+ Arguments.of("LocalDate <- Date", new Date(1704067200000L),
LocalDate.class, new
Date(1704067200000L).toInstant().atZone(ZoneId.systemDefault()).toLocalDate()),
+ Arguments.of("LocalDate <- LocalDateTime",
LocalDateTime.of(2024, 1, 1, 12, 30, 45), LocalDate.class, LocalDate.of(2024,
1, 1)),
+ Arguments.of("LocalDate <- SqlDate",
java.sql.Date.valueOf(LocalDate.of(2024, 1, 1)), LocalDate.class,
LocalDate.of(2024, 1, 1)),
+ Arguments.of("LocalDate <- String", "2024-08-05",
LocalDate.class, LocalDate.of(2024, 8, 5)),
+ Arguments.of("LocalDate <- String(LocalDateTime)",
"2024-08-05T12:30:45", LocalDate.class, LocalDate.of(2024, 8, 5)),
+ Arguments.of("LocalTime <- SqlTime", Time.valueOf("12:30:45"),
LocalTime.class, LocalTime.of(12, 30, 45)),
+ Arguments.of("LocalTime <- LocalDateTime",
LocalDateTime.of(2024, 1, 1, 12, 30, 45), LocalTime.class, LocalTime.of(12, 30,
45)),
+ Arguments.of("LocalTime <- String", "12:30:45",
LocalTime.class, LocalTime.of(12, 30, 45)),
+ Arguments.of("LocalDateTime <- Date", new
Date(1704067200000L), LocalDateTime.class, new
Date(1704067200000L).toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime()),
+ Arguments.of("LocalDateTime <- LocalDate", LocalDate.of(2024,
1, 1), LocalDateTime.class, LocalDateTime.of(2024, 1, 1, 0, 0)),
+ Arguments.of("LocalDateTime <- Timestamp",
Timestamp.valueOf("2024-01-01 12:30:45"), LocalDateTime.class,
LocalDateTime.of(2024, 1, 1, 12, 30, 45)),
+ Arguments.of("LocalDateTime <- String", "2024-08-05T12:30:45",
LocalDateTime.class, LocalDateTime.of(2024, 8, 5, 12, 30, 45)),
+ Arguments.of("Instant <- Long", 1704067200000L, Instant.class,
Instant.ofEpochMilli(1704067200000L)),
+ Arguments.of("Instant <- String", "2024-08-05T12:30:45Z",
Instant.class, Instant.parse("2024-08-05T12:30:45Z")),
+ Arguments.of("Instant <- String(LocalDate)", "2024-08-05",
Instant.class, LocalDate.of(2024, 8,
5).atStartOfDay(ZoneId.systemDefault()).toInstant()),
+ Arguments.of("Year <- Integer", 2024, Year.class,
Year.of(2024)),
+ Arguments.of("Year <- LocalDate", LocalDate.of(2024, 6, 15),
Year.class, Year.of(2024)),
+ Arguments.of("Year <- String", "2024", Year.class,
Year.of(2024)),
+ Arguments.of("YearMonth <- LocalDate", LocalDate.of(2024, 6,
15), YearMonth.class, YearMonth.of(2024, 6)),
+ Arguments.of("YearMonth <- String", "2024-08",
YearMonth.class, YearMonth.of(2024, 8)),
+ Arguments.of("MonthDay <- LocalDate", LocalDate.of(2024, 6,
15), MonthDay.class, MonthDay.of(6, 15)),
+ Arguments.of("MonthDay <- String", "--08-05", MonthDay.class,
MonthDay.of(8, 5)),
+ Arguments.of("Duration <- Long", 5000L, Duration.class,
Duration.ofMillis(5000L)),
+ Arguments.of("Duration <- String", "PT60S", Duration.class,
Duration.ofSeconds(60)));
+ }
+
+ private static Stream<Arguments> convertCollectionTypeArguments() {
+ return Stream.of(
+ Arguments.of("Integer", Arrays.asList((Comparable<?>[]) new
Comparable[]{1L, 2L, 3L, 4L}), Integer.class, 4, Integer.class),
+ Arguments.of("Long", Arrays.asList((Comparable<?>[]) new
Comparable[]{100, 200, 300}), Long.class, 3, Long.class),
+ Arguments.of("Double", Arrays.asList((Comparable<?>[]) new
Comparable[]{10, 20, 30}), Double.class, 3, Double.class),
+ Arguments.of("Collection Mixed -> Integer",
Arrays.asList((Comparable<?>[]) new Comparable[]{1, 2L, 3.0D, 4.0F}),
Integer.class, 4, Integer.class),
+ Arguments.of("BigDecimal", Arrays.asList((Comparable<?>[]) new
Comparable[]{100, 200L, 300.5D}), BigDecimal.class, 3, BigDecimal.class),
+ Arguments.of("BigInteger", Arrays.asList((Comparable<?>[]) new
Comparable[]{100, 200L, 300}), BigInteger.class, 3, BigInteger.class),
+ Arguments.of("Year", Arrays.asList((Comparable<?>[]) new
Comparable[]{LocalDate.of(2024, 1, 1),
+ LocalDate.of(2024, 2, 1), LocalDate.of(2024, 3, 1)}),
Year.class, 3, Year.class),
+ Arguments.of("Boolean", Arrays.asList((Comparable<?>[]) new
Comparable[]{1, 0, 2, "true"}), Boolean.class, 4, Boolean.class),
+ Arguments.of("Duration", Arrays.asList((Comparable<?>[]) new
Comparable[]{1000L, 2000L, 3000L}), Duration.class, 3, Duration.class));
}
}
diff --git
a/infra/common/src/test/java/org/apache/shardingsphere/infra/database/DatabaseTypeEngineTest.java
b/infra/common/src/test/java/org/apache/shardingsphere/infra/database/DatabaseTypeEngineTest.java
index 45cd6c7bad4..71287b67f3f 100644
---
a/infra/common/src/test/java/org/apache/shardingsphere/infra/database/DatabaseTypeEngineTest.java
+++
b/infra/common/src/test/java/org/apache/shardingsphere/infra/database/DatabaseTypeEngineTest.java
@@ -41,9 +41,9 @@ import java.sql.SQLFeatureNotSupportedException;
import java.util.Collections;
import java.util.Properties;
-import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.isA;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
import static org.mockito.Mockito.any;
@@ -151,7 +151,7 @@ class DatabaseTypeEngineTest {
try (MockedStatic<ShardingSphereServiceLoader> mocked =
mockStatic(ShardingSphereServiceLoader.class)) {
mocked.when(() ->
ShardingSphereServiceLoader.getServiceInstances(DialectJdbcUrlFetcher.class)).thenReturn(Collections.singleton(mock(DialectJdbcUrlFetcher.class)));
SQLWrapperException exception =
assertThrows(SQLWrapperException.class, () ->
DatabaseTypeEngine.getStorageType(new MockedDataSource(connection)));
- assertThat(exception.getCause(),
instanceOf(SQLFeatureNotSupportedException.class));
+ assertThat(exception.getCause(),
isA(SQLFeatureNotSupportedException.class));
}
}
@@ -165,7 +165,7 @@ class DatabaseTypeEngineTest {
when(dialectJdbcUrlFetcher.fetch(connection)).thenThrow(SQLException.class);
mocked.when(() ->
ShardingSphereServiceLoader.getServiceInstances(DialectJdbcUrlFetcher.class)).thenReturn(Collections.singleton(dialectJdbcUrlFetcher));
SQLWrapperException exception =
assertThrows(SQLWrapperException.class, () ->
DatabaseTypeEngine.getStorageType(new MockedDataSource(connection)));
- assertThat(exception.getCause(), instanceOf(SQLException.class));
+ assertThat(exception.getCause(), isA(SQLException.class));
}
}
}
diff --git
a/infra/common/src/test/java/org/apache/shardingsphere/infra/rule/attribute/RuleAttributesTest.java
b/infra/common/src/test/java/org/apache/shardingsphere/infra/rule/attribute/RuleAttributesTest.java
index e661645cb70..2582224c9f2 100644
---
a/infra/common/src/test/java/org/apache/shardingsphere/infra/rule/attribute/RuleAttributesTest.java
+++
b/infra/common/src/test/java/org/apache/shardingsphere/infra/rule/attribute/RuleAttributesTest.java
@@ -22,8 +22,8 @@ import org.junit.jupiter.api.Test;
import java.util.Optional;
import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.Matchers.instanceOf;
import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.isA;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
@@ -50,7 +50,7 @@ class RuleAttributesTest {
RuleAttribute attribute = mock(RuleAttribute.class);
RuleAttributes attributes = new RuleAttributes(attribute);
RuleAttribute actual = attributes.getAttribute(RuleAttribute.class);
- assertThat(actual, instanceOf(RuleAttribute.class));
+ assertThat(actual, isA(RuleAttribute.class));
}
@Test
diff --git
a/jdbc/src/test/java/org/apache/shardingsphere/driver/state/circuit/resultset/CircuitBreakerResultSetTest.java
b/jdbc/src/test/java/org/apache/shardingsphere/driver/state/circuit/resultset/CircuitBreakerResultSetTest.java
index c5e7e8a42d4..7e51f62ab64 100644
---
a/jdbc/src/test/java/org/apache/shardingsphere/driver/state/circuit/resultset/CircuitBreakerResultSetTest.java
+++
b/jdbc/src/test/java/org/apache/shardingsphere/driver/state/circuit/resultset/CircuitBreakerResultSetTest.java
@@ -22,10 +22,10 @@ import org.junit.jupiter.api.Test;
import java.sql.ResultSet;
import java.util.Calendar;
-import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.nullValue;
import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.isA;
import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
@SuppressWarnings("resource")
@@ -248,7 +248,7 @@ class CircuitBreakerResultSetTest {
@Test
void assertGetMetaData() {
- assertThat(new CircuitBreakerResultSet().getMetaData(),
instanceOf(CircuitBreakerResultSetMetaData.class));
+ assertThat(new CircuitBreakerResultSet().getMetaData(),
isA(CircuitBreakerResultSetMetaData.class));
}
@Test
diff --git
a/jdbc/src/test/java/org/apache/shardingsphere/driver/state/circuit/statement/CircuitBreakerPreparedStatementTest.java
b/jdbc/src/test/java/org/apache/shardingsphere/driver/state/circuit/statement/CircuitBreakerPreparedStatementTest.java
index 14e79d602ea..e647306b0af 100644
---
a/jdbc/src/test/java/org/apache/shardingsphere/driver/state/circuit/statement/CircuitBreakerPreparedStatementTest.java
+++
b/jdbc/src/test/java/org/apache/shardingsphere/driver/state/circuit/statement/CircuitBreakerPreparedStatementTest.java
@@ -35,10 +35,10 @@ import java.sql.Timestamp;
import java.util.Calendar;
import java.util.Collections;
-import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.nullValue;
import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.isA;
import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
@SuppressWarnings("resource")
@@ -276,12 +276,12 @@ class CircuitBreakerPreparedStatementTest {
@Test
void assertGetConnection() {
- assertThat(new CircuitBreakerPreparedStatement().getConnection(),
instanceOf(CircuitBreakerConnection.class));
+ assertThat(new CircuitBreakerPreparedStatement().getConnection(),
isA(CircuitBreakerConnection.class));
}
@Test
void assertGetGeneratedKeys() {
- assertThat(new CircuitBreakerPreparedStatement().getGeneratedKeys(),
instanceOf(CircuitBreakerResultSet.class));
+ assertThat(new CircuitBreakerPreparedStatement().getGeneratedKeys(),
isA(CircuitBreakerResultSet.class));
}
@Test
@@ -291,7 +291,7 @@ class CircuitBreakerPreparedStatementTest {
@Test
void assertGetResultSet() {
- assertThat(new CircuitBreakerPreparedStatement().getResultSet(),
instanceOf(CircuitBreakerResultSet.class));
+ assertThat(new CircuitBreakerPreparedStatement().getResultSet(),
isA(CircuitBreakerResultSet.class));
}
@Test
@@ -321,7 +321,7 @@ class CircuitBreakerPreparedStatementTest {
@Test
void assertExecuteQuery() {
- assertThat(new CircuitBreakerPreparedStatement().executeQuery(),
instanceOf(CircuitBreakerResultSet.class));
+ assertThat(new CircuitBreakerPreparedStatement().executeQuery(),
isA(CircuitBreakerResultSet.class));
}
@Test
diff --git
a/jdbc/src/test/java/org/apache/shardingsphere/driver/state/circuit/statement/CircuitBreakerStatementTest.java
b/jdbc/src/test/java/org/apache/shardingsphere/driver/state/circuit/statement/CircuitBreakerStatementTest.java
index 1345c9b389c..23e4e33401c 100644
---
a/jdbc/src/test/java/org/apache/shardingsphere/driver/state/circuit/statement/CircuitBreakerStatementTest.java
+++
b/jdbc/src/test/java/org/apache/shardingsphere/driver/state/circuit/statement/CircuitBreakerStatementTest.java
@@ -23,10 +23,10 @@ import org.junit.jupiter.api.Test;
import java.sql.ResultSet;
import java.sql.Statement;
-import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.nullValue;
import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.isA;
import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
@SuppressWarnings("resource")
@@ -144,7 +144,7 @@ class CircuitBreakerStatementTest {
@Test
void assertGetConnection() {
- assertThat(new CircuitBreakerStatement().getConnection(),
instanceOf(CircuitBreakerConnection.class));
+ assertThat(new CircuitBreakerStatement().getConnection(),
isA(CircuitBreakerConnection.class));
}
@Test
diff --git
a/kernel/data-pipeline/dialect/mysql/src/test/java/org/apache/shardingsphere/data/pipeline/mysql/ingest/incremental/binlog/data/unsigned/impl/MySQLBinlogUnsignedBigintHandlerTest.java
b/kernel/data-pipeline/dialect/mysql/src/test/java/org/apache/shardingsphere/data/pipeline/mysql/ingest/incremental/binlog/data/unsigned/impl/MySQLBinlogUnsignedBigintHandlerTest.java
index 3bbeb0b7854..0de55740b3e 100644
---
a/kernel/data-pipeline/dialect/mysql/src/test/java/org/apache/shardingsphere/data/pipeline/mysql/ingest/incremental/binlog/data/unsigned/impl/MySQLBinlogUnsignedBigintHandlerTest.java
+++
b/kernel/data-pipeline/dialect/mysql/src/test/java/org/apache/shardingsphere/data/pipeline/mysql/ingest/incremental/binlog/data/unsigned/impl/MySQLBinlogUnsignedBigintHandlerTest.java
@@ -22,9 +22,9 @@ import org.junit.jupiter.api.Test;
import java.io.Serializable;
import java.math.BigInteger;
-import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.isA;
class MySQLBinlogUnsignedBigintHandlerTest {
@@ -33,10 +33,10 @@ class MySQLBinlogUnsignedBigintHandlerTest {
@Test
void assertHandle() {
Serializable actual = handler.handle(1L);
- assertThat(actual, instanceOf(BigInteger.class));
+ assertThat(actual, isA(BigInteger.class));
assertThat(actual, is(new BigInteger("1")));
actual = handler.handle(-1L);
- assertThat(actual, instanceOf(BigInteger.class));
+ assertThat(actual, isA(BigInteger.class));
assertThat(actual, is(new BigInteger("18446744073709551615")));
}
}
diff --git
a/kernel/data-pipeline/dialect/mysql/src/test/java/org/apache/shardingsphere/data/pipeline/mysql/ingest/incremental/binlog/data/unsigned/impl/MySQLBinlogUnsignedIntHandlerTest.java
b/kernel/data-pipeline/dialect/mysql/src/test/java/org/apache/shardingsphere/data/pipeline/mysql/ingest/incremental/binlog/data/unsigned/impl/MySQLBinlogUnsignedIntHandlerTest.java
index 0ef0fb4f7ec..3dc1c1c551a 100644
---
a/kernel/data-pipeline/dialect/mysql/src/test/java/org/apache/shardingsphere/data/pipeline/mysql/ingest/incremental/binlog/data/unsigned/impl/MySQLBinlogUnsignedIntHandlerTest.java
+++
b/kernel/data-pipeline/dialect/mysql/src/test/java/org/apache/shardingsphere/data/pipeline/mysql/ingest/incremental/binlog/data/unsigned/impl/MySQLBinlogUnsignedIntHandlerTest.java
@@ -21,9 +21,9 @@ import org.junit.jupiter.api.Test;
import java.io.Serializable;
-import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.isA;
class MySQLBinlogUnsignedIntHandlerTest {
@@ -32,10 +32,10 @@ class MySQLBinlogUnsignedIntHandlerTest {
@Test
void assertHandle() {
Serializable actual = handler.handle(1);
- assertThat(actual, instanceOf(Long.class));
+ assertThat(actual, isA(Long.class));
assertThat(actual, is(1L));
actual = handler.handle(-1);
- assertThat(actual, instanceOf(Long.class));
+ assertThat(actual, isA(Long.class));
assertThat(actual, is(4294967295L));
}
}
diff --git
a/kernel/data-pipeline/dialect/mysql/src/test/java/org/apache/shardingsphere/data/pipeline/mysql/ingest/incremental/binlog/data/unsigned/impl/MySQLBinlogUnsignedMediumintHandlerTest.java
b/kernel/data-pipeline/dialect/mysql/src/test/java/org/apache/shardingsphere/data/pipeline/mysql/ingest/incremental/binlog/data/unsigned/impl/MySQLBinlogUnsignedMediumintHandlerTest.java
index 93d2f9ffd67..352689c2a29 100644
---
a/kernel/data-pipeline/dialect/mysql/src/test/java/org/apache/shardingsphere/data/pipeline/mysql/ingest/incremental/binlog/data/unsigned/impl/MySQLBinlogUnsignedMediumintHandlerTest.java
+++
b/kernel/data-pipeline/dialect/mysql/src/test/java/org/apache/shardingsphere/data/pipeline/mysql/ingest/incremental/binlog/data/unsigned/impl/MySQLBinlogUnsignedMediumintHandlerTest.java
@@ -21,9 +21,9 @@ import org.junit.jupiter.api.Test;
import java.io.Serializable;
-import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.isA;
class MySQLBinlogUnsignedMediumintHandlerTest {
@@ -32,10 +32,10 @@ class MySQLBinlogUnsignedMediumintHandlerTest {
@Test
void assertHandle() {
Serializable actual = handler.handle(1);
- assertThat(actual, instanceOf(Integer.class));
+ assertThat(actual, isA(Integer.class));
assertThat(actual, is(1));
actual = handler.handle(-1);
- assertThat(actual, instanceOf(Integer.class));
+ assertThat(actual, isA(Integer.class));
assertThat(actual, is(16777215));
}
}
diff --git
a/kernel/data-pipeline/dialect/mysql/src/test/java/org/apache/shardingsphere/data/pipeline/mysql/ingest/incremental/binlog/data/unsigned/impl/MySQLBinlogUnsignedSmallintHandlerTest.java
b/kernel/data-pipeline/dialect/mysql/src/test/java/org/apache/shardingsphere/data/pipeline/mysql/ingest/incremental/binlog/data/unsigned/impl/MySQLBinlogUnsignedSmallintHandlerTest.java
index 28cab367dd5..4af6b241497 100644
---
a/kernel/data-pipeline/dialect/mysql/src/test/java/org/apache/shardingsphere/data/pipeline/mysql/ingest/incremental/binlog/data/unsigned/impl/MySQLBinlogUnsignedSmallintHandlerTest.java
+++
b/kernel/data-pipeline/dialect/mysql/src/test/java/org/apache/shardingsphere/data/pipeline/mysql/ingest/incremental/binlog/data/unsigned/impl/MySQLBinlogUnsignedSmallintHandlerTest.java
@@ -21,9 +21,9 @@ import org.junit.jupiter.api.Test;
import java.io.Serializable;
-import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.isA;
class MySQLBinlogUnsignedSmallintHandlerTest {
@@ -32,10 +32,10 @@ class MySQLBinlogUnsignedSmallintHandlerTest {
@Test
void assertHandle() {
Serializable actual = handler.handle((short) 1);
- assertThat(actual, instanceOf(Integer.class));
+ assertThat(actual, isA(Integer.class));
assertThat(actual, is(1));
actual = handler.handle((short) -1);
- assertThat(actual, instanceOf(Integer.class));
+ assertThat(actual, isA(Integer.class));
assertThat(actual, is(65535));
}
}
diff --git
a/kernel/data-pipeline/dialect/mysql/src/test/java/org/apache/shardingsphere/data/pipeline/mysql/ingest/incremental/binlog/data/unsigned/impl/MySQLBinlogUnsignedTinyintHandlerTest.java
b/kernel/data-pipeline/dialect/mysql/src/test/java/org/apache/shardingsphere/data/pipeline/mysql/ingest/incremental/binlog/data/unsigned/impl/MySQLBinlogUnsignedTinyintHandlerTest.java
index 3d21d22a8dc..f0e3f421380 100644
---
a/kernel/data-pipeline/dialect/mysql/src/test/java/org/apache/shardingsphere/data/pipeline/mysql/ingest/incremental/binlog/data/unsigned/impl/MySQLBinlogUnsignedTinyintHandlerTest.java
+++
b/kernel/data-pipeline/dialect/mysql/src/test/java/org/apache/shardingsphere/data/pipeline/mysql/ingest/incremental/binlog/data/unsigned/impl/MySQLBinlogUnsignedTinyintHandlerTest.java
@@ -21,9 +21,9 @@ import org.junit.jupiter.api.Test;
import java.io.Serializable;
-import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.isA;
class MySQLBinlogUnsignedTinyintHandlerTest {
@@ -32,10 +32,10 @@ class MySQLBinlogUnsignedTinyintHandlerTest {
@Test
void assertHandle() {
Serializable actual = handler.handle((byte) 1);
- assertThat(actual, instanceOf(Short.class));
+ assertThat(actual, isA(Short.class));
assertThat(actual, is((short) 1));
actual = handler.handle((byte) -1);
- assertThat(actual, instanceOf(Short.class));
+ assertThat(actual, isA(Short.class));
assertThat(actual, is((short) 255));
}
}
diff --git
a/kernel/data-pipeline/scenario/cdc/core/src/test/java/org/apache/shardingsphere/data/pipeline/cdc/config/yaml/swapper/YamlCDCJobConfigurationSwapperTest.java
b/kernel/data-pipeline/scenario/cdc/core/src/test/java/org/apache/shardingsphere/data/pipeline/cdc/config/yaml/swapper/YamlCDCJobConfigurationSwapperTest.java
index 7bc492f09f3..e27320d6d5c 100644
---
a/kernel/data-pipeline/scenario/cdc/core/src/test/java/org/apache/shardingsphere/data/pipeline/cdc/config/yaml/swapper/YamlCDCJobConfigurationSwapperTest.java
+++
b/kernel/data-pipeline/scenario/cdc/core/src/test/java/org/apache/shardingsphere/data/pipeline/cdc/config/yaml/swapper/YamlCDCJobConfigurationSwapperTest.java
@@ -47,7 +47,7 @@ import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.empty;
import static org.hamcrest.Matchers.hasSize;
-import static org.hamcrest.Matchers.instanceOf;
+import static org.hamcrest.Matchers.isA;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
@@ -165,7 +165,7 @@ class YamlCDCJobConfigurationSwapperTest {
assertThat(actual.getJobId(),
is("j0302p00007a8bf46da145dc155ba25c710b550220"));
assertThat(actual.getJobShardingDataNodes(), empty());
assertNull(actual.getTablesFirstDataNodes());
- assertThat(actual.getDataSourceConfig(),
instanceOf(ShardingSpherePipelineDataSourceConfiguration.class));
+ assertThat(actual.getDataSourceConfig(),
isA(ShardingSpherePipelineDataSourceConfiguration.class));
assertThat(actual.getSinkConfig().getProps().getProperty("foo_key"),
is("foo_value"));
assertFalse(actual.isDecodeWithTX());
}
diff --git
a/kernel/data-pipeline/scenario/cdc/core/src/test/java/org/apache/shardingsphere/data/pipeline/cdc/core/importer/CDCImporterTest.java
b/kernel/data-pipeline/scenario/cdc/core/src/test/java/org/apache/shardingsphere/data/pipeline/cdc/core/importer/CDCImporterTest.java
index 48569d7dedb..8ceddb720e1 100644
---
a/kernel/data-pipeline/scenario/cdc/core/src/test/java/org/apache/shardingsphere/data/pipeline/cdc/core/importer/CDCImporterTest.java
+++
b/kernel/data-pipeline/scenario/cdc/core/src/test/java/org/apache/shardingsphere/data/pipeline/cdc/core/importer/CDCImporterTest.java
@@ -39,10 +39,10 @@ import java.util.Queue;
import java.util.concurrent.atomic.AtomicReference;
import java.util.stream.Collectors;
-import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.contains;
+import static org.hamcrest.Matchers.isA;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyCollection;
@@ -81,7 +81,7 @@ class CDCImporterTest {
CDCImporter importer = new CDCImporter(new
LinkedList<>(Collections.singletonList(new CDCChannelProgressPair(channel,
progressListener))), 1, 1L, sink, false, null);
importer.start();
importer.stop();
- assertThat(captureAckRecords(channel, 1).get(0).get(0),
instanceOf(FinishedRecord.class));
+ assertThat(captureAckRecords(channel, 1).get(0).get(0),
isA(FinishedRecord.class));
assertThat(captureProgressCounts(progressListener, 2), contains(0, 0));
}
@@ -113,7 +113,7 @@ class CDCImporterTest {
importer.stop();
List<List<Record>> ackedRecords = captureAckRecords(channel, 1);
assertThat(ackedRecords.size(), is(1));
- assertThat(ackedRecords.get(0).get(0),
instanceOf(FinishedRecord.class));
+ assertThat(ackedRecords.get(0).get(0), isA(FinishedRecord.class));
assertThat(captureProgressCounts(progressListener, 2), contains(0, 1));
}
diff --git
a/kernel/data-pipeline/scenario/consistency-check/src/test/java/org/apache/shardingsphere/data/pipeline/scenario/consistencycheck/context/ConsistencyCheckJobItemContextTest.java
b/kernel/data-pipeline/scenario/consistency-check/src/test/java/org/apache/shardingsphere/data/pipeline/scenario/consistencycheck/context/ConsistencyCheckJobItemContextTest.java
index f1e70f0c64d..a2814ef01ca 100644
---
a/kernel/data-pipeline/scenario/consistency-check/src/test/java/org/apache/shardingsphere/data/pipeline/scenario/consistencycheck/context/ConsistencyCheckJobItemContextTest.java
+++
b/kernel/data-pipeline/scenario/consistency-check/src/test/java/org/apache/shardingsphere/data/pipeline/scenario/consistencycheck/context/ConsistencyCheckJobItemContextTest.java
@@ -30,8 +30,8 @@ import org.junit.jupiter.api.Test;
import java.math.BigInteger;
import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.Matchers.instanceOf;
import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.isA;
class ConsistencyCheckJobItemContextTest {
@@ -82,7 +82,7 @@ class ConsistencyCheckJobItemContextTest {
private void assertRange(final UniqueKeyIngestPosition<?> actual, final
UniqueKeyIngestPosition<?> expected) {
assertThat(actual.getClass(), is(expected.getClass()));
- assertThat(actual, instanceOf(UniqueKeyIngestPosition.class));
+ assertThat(actual, isA(UniqueKeyIngestPosition.class));
assertThat(actual.getLowerBound(), is(expected.getLowerBound()));
assertThat(actual.getUpperBound(), is(expected.getUpperBound()));
}
diff --git
a/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/segment/expression/impl/FunctionConverterTest.java
b/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/segment/expression/impl/FunctionConverterTest.java
index 53b2e76612e..a82e32b4534 100644
---
a/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/segment/expression/impl/FunctionConverterTest.java
+++
b/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/segment/expression/impl/FunctionConverterTest.java
@@ -44,9 +44,9 @@ import java.util.Arrays;
import java.util.Collections;
import java.util.Optional;
-import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.isA;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
@@ -124,7 +124,7 @@ class FunctionConverterTest {
when(OwnerConverter.convert(owner)).thenReturn(new ArrayList<>());
when(ExpressionConverter.convert(param)).thenReturn(Optional.of(paramNode));
SqlBasicCall actual = (SqlBasicCall)
FunctionConverter.convert(segment);
- assertThat(actual.getOperator(),
instanceOf(SqlUnresolvedFunction.class));
+ assertThat(actual.getOperator(), isA(SqlUnresolvedFunction.class));
SqlIdentifier functionName = actual.getOperator().getNameAsId();
assertThat(functionName.names,
is(Collections.singletonList("custom_func")));
assertThat(functionName.getSimple(), is("custom_func"));
diff --git
a/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/segment/expression/impl/InExpressionConverterTest.java
b/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/segment/expression/impl/InExpressionConverterTest.java
index fa74cd2d70d..eca4886d31c 100644
---
a/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/segment/expression/impl/InExpressionConverterTest.java
+++
b/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/segment/expression/impl/InExpressionConverterTest.java
@@ -34,9 +34,9 @@ import java.util.Arrays;
import java.util.Collections;
import java.util.Optional;
-import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.isA;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
@@ -56,7 +56,7 @@ class InExpressionConverterTest {
SqlBasicCall actual = InExpressionConverter.convert(new
InExpression(0, 0, left, right, true));
assertThat(actual.getOperator(), is(SqlStdOperatorTable.NOT_IN));
SqlNode secondOperand = actual.getOperandList().get(1);
- assertThat(secondOperand, instanceOf(SqlNodeList.class));
+ assertThat(secondOperand, isA(SqlNodeList.class));
assertThat(((SqlNodeList) secondOperand).size(), is(1));
assertThat(((SqlNodeList) secondOperand).get(0), is(rightOperand));
}
diff --git
a/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/segment/expression/impl/MatchExpressionConverterTest.java
b/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/segment/expression/impl/MatchExpressionConverterTest.java
index 888f61ff4ce..8181a63a01d 100644
---
a/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/segment/expression/impl/MatchExpressionConverterTest.java
+++
b/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/segment/expression/impl/MatchExpressionConverterTest.java
@@ -36,9 +36,9 @@ import org.junit.jupiter.api.extension.ExtendWith;
import java.util.Arrays;
import java.util.Optional;
-import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.isA;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
@@ -76,7 +76,7 @@ class MatchExpressionConverterTest {
segment.getColumns().add(columnSegment);
SqlBasicCall actual = MatchExpressionConverter.convert(segment);
assertThat(actual.getOperandList().size(), is(2));
- assertThat(actual.getOperandList().get(0),
instanceOf(SqlIdentifier.class));
+ assertThat(actual.getOperandList().get(0), isA(SqlIdentifier.class));
SqlLiteral modifier = (SqlLiteral) actual.getOperandList().get(1);
assertThat(modifier.getValueAs(String.class), is("modifier"));
}
diff --git
a/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/segment/expression/impl/TypeCastExpressionConverterTest.java
b/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/segment/expression/impl/TypeCastExpressionConverterTest.java
index 56c132db8fb..2422fe1eede 100644
---
a/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/segment/expression/impl/TypeCastExpressionConverterTest.java
+++
b/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/segment/expression/impl/TypeCastExpressionConverterTest.java
@@ -30,9 +30,9 @@ import org.junit.jupiter.api.extension.ExtendWith;
import java.util.Optional;
-import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.isA;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.mockito.Mockito.mock;
@@ -59,6 +59,6 @@ class TypeCastExpressionConverterTest {
SqlBasicCall actual = (SqlBasicCall)
TypeCastExpressionConverter.convert(typeCastExpression).orElse(null);
assertNotNull(actual);
assertThat(actual.getOperandList().get(0), is(expressionNode));
- assertThat(actual.getOperandList().get(1),
instanceOf(SqlDataTypeSpec.class));
+ assertThat(actual.getOperandList().get(1), isA(SqlDataTypeSpec.class));
}
}
diff --git
a/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/segment/expression/impl/WindowFunctionConverterTest.java
b/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/segment/expression/impl/WindowFunctionConverterTest.java
index b76baacac58..685a1cd3331 100644
---
a/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/segment/expression/impl/WindowFunctionConverterTest.java
+++
b/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/segment/expression/impl/WindowFunctionConverterTest.java
@@ -31,9 +31,9 @@ import org.junit.jupiter.api.extension.ExtendWith;
import java.util.Optional;
-import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.isA;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
@@ -52,7 +52,7 @@ class WindowFunctionConverterTest {
SqlBasicCall actual = WindowFunctionConverter.convert(segment);
assertThat(actual.getOperator(), is(SqlStdOperatorTable.OVER));
assertThat(actual.getOperandList().get(0), is(paramNode));
- assertThat(actual.getOperandList().get(1),
instanceOf(SqlWindow.class));
+ assertThat(actual.getOperandList().get(1), isA(SqlWindow.class));
}
@Test
@@ -61,7 +61,6 @@ class WindowFunctionConverterTest {
LiteralExpressionSegment parameter = new LiteralExpressionSegment(0,
0, "value");
segment.getParameters().add(parameter);
when(ExpressionConverter.convert(parameter)).thenReturn(Optional.empty());
- SqlBasicCall actual = WindowFunctionConverter.convert(segment);
- assertTrue(actual.getOperandList().isEmpty());
+
assertTrue(WindowFunctionConverter.convert(segment).getOperandList().isEmpty());
}
}
diff --git
a/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/segment/from/impl/JoinTableConverterTest.java
b/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/segment/from/impl/JoinTableConverterTest.java
index 4a5c87e5938..1183a878065 100644
---
a/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/segment/from/impl/JoinTableConverterTest.java
+++
b/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/segment/from/impl/JoinTableConverterTest.java
@@ -40,9 +40,9 @@ import java.util.ArrayList;
import java.util.Collections;
import java.util.Optional;
-import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.isA;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
@@ -98,7 +98,7 @@ class JoinTableConverterTest {
assertNotNull(actual);
assertThat(actual.getJoinType(), is(JoinType.INNER));
assertThat(actual.getConditionType(), is(JoinConditionType.USING));
- assertThat(actual.getCondition(), instanceOf(SqlNodeList.class));
+ assertThat(actual.getCondition(), isA(SqlNodeList.class));
assertNotNull(actual.getCondition());
assertThat(((SqlNodeList) actual.getCondition()).get(0),
is(usingNode));
assertTrue(actual.isNaturalNode().booleanValue());
diff --git
a/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/segment/from/impl/SimpleTableConverterTest.java
b/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/segment/from/impl/SimpleTableConverterTest.java
index f72eb09094c..b2750d00a0d 100644
---
a/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/segment/from/impl/SimpleTableConverterTest.java
+++
b/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/segment/from/impl/SimpleTableConverterTest.java
@@ -30,9 +30,9 @@ import org.junit.jupiter.api.Test;
import java.util.Arrays;
import java.util.Collections;
-import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.isA;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
@@ -64,6 +64,6 @@ class SimpleTableConverterTest {
assertThat(actual.getOperator(), is(SqlStdOperatorTable.AS));
assertThat(((SqlIdentifier) actual.getOperandList().get(0)).names,
is(Arrays.asList("schema", "t_complex", "db", "remote")));
assertThat(((SqlIdentifier) actual.getOperandList().get(1)).names,
is(Collections.singletonList("t_alias")));
- assertThat(actual.getOperandList().get(0),
instanceOf(SqlIdentifier.class));
+ assertThat(actual.getOperandList().get(0), isA(SqlIdentifier.class));
}
}
diff --git
a/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/segment/from/impl/SubqueryTableConverterTest.java
b/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/segment/from/impl/SubqueryTableConverterTest.java
index ea96df398a7..b0356561082 100644
---
a/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/segment/from/impl/SubqueryTableConverterTest.java
+++
b/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/segment/from/impl/SubqueryTableConverterTest.java
@@ -44,9 +44,9 @@ import org.junit.jupiter.api.extension.ExtendWith;
import java.util.Collections;
import java.util.Optional;
-import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.isA;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.mockito.Mockito.mock;
@@ -72,7 +72,7 @@ class SubqueryTableConverterTest {
SqlBasicCall actual = (SqlBasicCall)
SubqueryTableConverter.convert(segment).orElse(null);
assertNotNull(actual);
assertThat(actual.getOperator(), is(SqlStdOperatorTable.AS));
- assertThat(actual.getOperandList().get(0),
instanceOf(SqlBasicCall.class));
+ assertThat(actual.getOperandList().get(0), isA(SqlBasicCall.class));
SqlBasicCall explicitTable = (SqlBasicCall)
actual.getOperandList().get(0);
assertThat(explicitTable.getOperator(),
is(SqlStdOperatorTable.EXPLICIT_TABLE));
assertThat(((SqlIdentifier) actual.getOperandList().get(1)).names,
is(Collections.singletonList("alias")));
@@ -89,7 +89,7 @@ class SubqueryTableConverterTest {
SqlBasicCall actual = (SqlBasicCall)
SubqueryTableConverter.convert(segment).orElse(null);
assertNotNull(actual);
assertThat(actual.getOperator(), is(SqlStdOperatorTable.AS));
- assertThat(actual.getOperandList().get(0),
instanceOf(SqlSelect.class));
+ assertThat(actual.getOperandList().get(0), isA(SqlSelect.class));
assertThat(actual.getOperandList().size(), is(1));
}
}
diff --git
a/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/segment/projection/impl/AggregationProjectionConverterTest.java
b/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/segment/projection/impl/AggregationProjectionConverterTest.java
index 36f4d17b7f7..7e858dedae2 100644
---
a/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/segment/projection/impl/AggregationProjectionConverterTest.java
+++
b/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/segment/projection/impl/AggregationProjectionConverterTest.java
@@ -38,9 +38,9 @@ import java.util.Arrays;
import java.util.Collections;
import java.util.Optional;
-import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.isA;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
@@ -70,7 +70,7 @@ class AggregationProjectionConverterTest {
assertThat(innerCall.getOperator(), is(SqlStdOperatorTable.COUNT));
assertNotNull(innerCall.getFunctionQuantifier());
assertThat(innerCall.getOperandList().size(), is(1));
- assertThat(innerCall.getOperandList().get(0),
instanceOf(SqlIdentifier.class));
+ assertThat(innerCall.getOperandList().get(0),
isA(SqlIdentifier.class));
SqlIdentifier starIdentifier = (SqlIdentifier)
innerCall.getOperandList().get(0);
assertTrue(starIdentifier.isStar());
SqlIdentifier aliasIdentifier = (SqlIdentifier)
asCall.getOperandList().get(1);
@@ -94,7 +94,7 @@ class AggregationProjectionConverterTest {
assertThat(sqlBasicCall.getOperandList().size(), is(3));
assertThat(sqlBasicCall.getOperandList().get(0), is(firstNode));
assertThat(sqlBasicCall.getOperandList().get(1), is(secondNode));
- assertThat(sqlBasicCall.getOperandList().get(2),
instanceOf(SqlLiteral.class));
+ assertThat(sqlBasicCall.getOperandList().get(2),
isA(SqlLiteral.class));
assertNull(sqlBasicCall.getFunctionQuantifier());
}
diff --git
a/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/segment/projection/impl/ColumnProjectionConverterTest.java
b/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/segment/projection/impl/ColumnProjectionConverterTest.java
index 25cfd55a98b..bbf520bdabf 100644
---
a/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/segment/projection/impl/ColumnProjectionConverterTest.java
+++
b/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/segment/projection/impl/ColumnProjectionConverterTest.java
@@ -33,9 +33,9 @@ import org.junit.jupiter.api.extension.ExtendWith;
import java.util.Collections;
-import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.isA;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
@@ -51,7 +51,7 @@ class ColumnProjectionConverterTest {
SqlIdentifier columnNode = new SqlIdentifier("col", SqlParserPos.ZERO);
when(ColumnConverter.convert(columnSegment)).thenReturn(columnNode);
SqlBasicCall actual = (SqlBasicCall)
ColumnProjectionConverter.convert(projectionSegment);
- assertThat(actual.getOperator(), instanceOf(SqlAsOperator.class));
+ assertThat(actual.getOperator(), isA(SqlAsOperator.class));
assertThat(actual.getOperandList().get(0), is(columnNode));
assertThat(((SqlIdentifier) actual.getOperandList().get(1)).names,
is(Collections.singletonList("alias")));
}
diff --git
a/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/statement/type/InsertStatementConverterTest.java
b/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/statement/type/InsertStatementConverterTest.java
index 4236a8ead5c..314fe584ca3 100644
---
a/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/statement/type/InsertStatementConverterTest.java
+++
b/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/statement/type/InsertStatementConverterTest.java
@@ -30,10 +30,10 @@ import
org.apache.shardingsphere.sql.parser.statement.core.segment.dml.column.Co
import
org.apache.shardingsphere.sql.parser.statement.core.segment.dml.column.InsertColumnsSegment;
import
org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.simple.ParameterMarkerExpressionSegment;
import
org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.subquery.SubquerySegment;
-import
org.apache.shardingsphere.sql.parser.statement.core.segment.generic.table.SimpleTableSegment;
-import
org.apache.shardingsphere.sql.parser.statement.core.segment.generic.table.TableNameSegment;
import
org.apache.shardingsphere.sql.parser.statement.core.segment.dml.item.ColumnProjectionSegment;
import
org.apache.shardingsphere.sql.parser.statement.core.segment.dml.item.ProjectionsSegment;
+import
org.apache.shardingsphere.sql.parser.statement.core.segment.generic.table.SimpleTableSegment;
+import
org.apache.shardingsphere.sql.parser.statement.core.segment.generic.table.TableNameSegment;
import
org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.InsertStatement;
import
org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.SelectStatement;
import
org.apache.shardingsphere.sql.parser.statement.core.value.identifier.IdentifierValue;
@@ -41,9 +41,8 @@ import org.junit.jupiter.api.Test;
import java.util.Collections;
-import static org.hamcrest.CoreMatchers.instanceOf;
-import static org.hamcrest.CoreMatchers.isA;
import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.isA;
import static org.junit.jupiter.api.Assertions.assertNull;
class InsertStatementConverterTest {
@@ -70,8 +69,8 @@ class InsertStatementConverterTest {
insertStatement.setInsertColumns(new InsertColumnsSegment(0, 0,
Collections.emptyList()));
SqlInsert actual = (SqlInsert) new
InsertStatementConverter().convert(insertStatement);
assertThat(actual.getTargetTable(), isA(SqlNode.class));
- assertThat(actual.getSource(), instanceOf(SqlBasicCall.class));
- assertThat(actual.getTargetColumnList(),
instanceOf(SqlNodeList.class));
+ assertThat(actual.getSource(), isA(SqlBasicCall.class));
+ assertThat(actual.getTargetColumnList(), isA(SqlNodeList.class));
}
@Test
@@ -80,7 +79,7 @@ class InsertStatementConverterTest {
insertStatement.setTable(new SimpleTableSegment(new
TableNameSegment(0, 0, new IdentifierValue("t_insert_values"))));
insertStatement.getValues().add(new InsertValuesSegment(0, 0,
Collections.singletonList(new ParameterMarkerExpressionSegment(0, 0, 0))));
SqlInsert actual = (SqlInsert) new
InsertStatementConverter().convert(insertStatement);
- assertThat(actual.getSource(), instanceOf(SqlBasicCall.class));
+ assertThat(actual.getSource(), isA(SqlBasicCall.class));
assertNull(actual.getTargetColumnList());
}
@@ -92,7 +91,7 @@ class InsertStatementConverterTest {
insertStatement.setInsertColumns(insertColumnsSegment);
insertStatement.getValues().add(new InsertValuesSegment(0, 0,
Collections.singletonList(new ParameterMarkerExpressionSegment(0, 0, 0))));
SqlInsert actual = (SqlInsert) new
InsertStatementConverter().convert(insertStatement);
- assertThat(actual.getTargetColumnList(),
instanceOf(SqlNodeList.class));
+ assertThat(actual.getTargetColumnList(), isA(SqlNodeList.class));
}
private ProjectionsSegment createProjectionsSegment() {
diff --git
a/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/statement/type/SelectStatementConverterTest.java
b/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/statement/type/SelectStatementConverterTest.java
index de7f5857be8..53b585c26ff 100644
---
a/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/statement/type/SelectStatementConverterTest.java
+++
b/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/statement/type/SelectStatementConverterTest.java
@@ -26,9 +26,14 @@ import
org.apache.shardingsphere.database.connector.core.type.DatabaseType;
import org.apache.shardingsphere.infra.spi.type.typed.TypedSPILoader;
import org.apache.shardingsphere.sql.parser.statement.core.enums.CombineType;
import
org.apache.shardingsphere.sql.parser.statement.core.enums.OrderDirection;
+import
org.apache.shardingsphere.sql.parser.statement.core.segment.dml.column.ColumnSegment;
import
org.apache.shardingsphere.sql.parser.statement.core.segment.dml.combine.CombineSegment;
-import
org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.subquery.SubquerySegment;
import
org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.simple.ParameterMarkerExpressionSegment;
+import
org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.subquery.SubquerySegment;
+import
org.apache.shardingsphere.sql.parser.statement.core.segment.dml.item.ColumnProjectionSegment;
+import
org.apache.shardingsphere.sql.parser.statement.core.segment.dml.item.ProjectionsSegment;
+import
org.apache.shardingsphere.sql.parser.statement.core.segment.dml.order.OrderBySegment;
+import
org.apache.shardingsphere.sql.parser.statement.core.segment.dml.order.item.ColumnOrderByItemSegment;
import
org.apache.shardingsphere.sql.parser.statement.core.segment.dml.pagination.limit.LimitSegment;
import
org.apache.shardingsphere.sql.parser.statement.core.segment.dml.pagination.limit.NumberLiteralLimitValueSegment;
import
org.apache.shardingsphere.sql.parser.statement.core.segment.dml.pagination.limit.ParameterMarkerLimitValueSegment;
@@ -37,22 +42,16 @@ import
org.apache.shardingsphere.sql.parser.statement.core.segment.generic.Alias
import
org.apache.shardingsphere.sql.parser.statement.core.segment.generic.WindowItemSegment;
import
org.apache.shardingsphere.sql.parser.statement.core.segment.generic.WindowSegment;
import
org.apache.shardingsphere.sql.parser.statement.core.segment.generic.WithSegment;
-import
org.apache.shardingsphere.sql.parser.statement.core.segment.dml.order.OrderBySegment;
-import
org.apache.shardingsphere.sql.parser.statement.core.segment.dml.order.item.ColumnOrderByItemSegment;
import
org.apache.shardingsphere.sql.parser.statement.core.segment.generic.table.SimpleTableSegment;
import
org.apache.shardingsphere.sql.parser.statement.core.segment.generic.table.TableNameSegment;
-import
org.apache.shardingsphere.sql.parser.statement.core.segment.dml.column.ColumnSegment;
-import
org.apache.shardingsphere.sql.parser.statement.core.segment.dml.item.ColumnProjectionSegment;
-import
org.apache.shardingsphere.sql.parser.statement.core.segment.dml.item.ProjectionsSegment;
-import
org.apache.shardingsphere.sql.parser.statement.core.value.identifier.IdentifierValue;
import
org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.SelectStatement;
+import
org.apache.shardingsphere.sql.parser.statement.core.value.identifier.IdentifierValue;
import org.junit.jupiter.api.Test;
import java.util.Collections;
-import static org.hamcrest.CoreMatchers.instanceOf;
-import static org.hamcrest.CoreMatchers.isA;
import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.isA;
import static org.junit.jupiter.api.Assertions.assertNull;
class SelectStatementConverterTest {
@@ -69,9 +68,9 @@ class SelectStatementConverterTest {
LimitSegment limit = new LimitSegment(0, 0, new
NumberLiteralLimitValueSegment(0, 0, 1L), new
ParameterMarkerLimitValueSegment(0, 0, 0));
selectStatement.setLimit(limit);
SqlOrderBy actual = (SqlOrderBy) new
SelectStatementConverter().convert(selectStatement);
- assertThat(actual.offset, instanceOf(SqlNode.class));
- assertThat(actual.fetch, instanceOf(SqlNode.class));
- assertThat(actual.query, instanceOf(SqlBasicCall.class));
+ assertThat(actual.offset, isA(SqlNode.class));
+ assertThat(actual.fetch, isA(SqlNode.class));
+ assertThat(actual.query, isA(SqlBasicCall.class));
}
@Test
diff --git
a/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/statement/type/UpdateStatementConverterTest.java
b/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/statement/type/UpdateStatementConverterTest.java
index 055e0c6ca8e..65494688118 100644
---
a/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/statement/type/UpdateStatementConverterTest.java
+++
b/kernel/sql-federation/compiler/src/test/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/statement/type/UpdateStatementConverterTest.java
@@ -45,8 +45,8 @@ import org.junit.jupiter.api.Test;
import java.util.Collections;
-import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.isA;
import static org.junit.jupiter.api.Assertions.assertNull;
class UpdateStatementConverterTest {
@@ -59,10 +59,10 @@ class UpdateStatementConverterTest {
LimitSegment limit = new LimitSegment(0, 0, new
NumberLiteralLimitValueSegment(0, 0, 1L), new
ParameterMarkerLimitValueSegment(0, 0, 0));
updateStatement.setLimit(limit);
SqlOrderBy actual = (SqlOrderBy) new
UpdateStatementConverter().convert(updateStatement);
- assertThat(actual.offset, instanceOf(SqlNode.class));
- assertThat(actual.fetch, instanceOf(SqlDynamicParam.class));
+ assertThat(actual.offset, isA(SqlNode.class));
+ assertThat(actual.fetch, isA(SqlDynamicParam.class));
SqlUpdate sqlUpdate = (SqlUpdate) actual.query;
- assertThat(sqlUpdate.getAlias(), instanceOf(SqlIdentifier.class));
+ assertThat(sqlUpdate.getAlias(), isA(SqlIdentifier.class));
}
@Test
diff --git
a/kernel/sql-federation/executor/src/test/java/org/apache/shardingsphere/sqlfederation/executor/enumerable/enumerator/jdbc/JDBCDataRowEnumeratorTest.java
b/kernel/sql-federation/executor/src/test/java/org/apache/shardingsphere/sqlfederation/executor/enumerable/enumerator/jdbc/JDBCDataRowEnumeratorTest.java
index 46b25433d15..1c61bc5880f 100644
---
a/kernel/sql-federation/executor/src/test/java/org/apache/shardingsphere/sqlfederation/executor/enumerable/enumerator/jdbc/JDBCDataRowEnumeratorTest.java
+++
b/kernel/sql-federation/executor/src/test/java/org/apache/shardingsphere/sqlfederation/executor/enumerable/enumerator/jdbc/JDBCDataRowEnumeratorTest.java
@@ -31,7 +31,6 @@ import java.util.Collections;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.Matchers.instanceOf;
import static org.hamcrest.Matchers.isA;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNull;
@@ -58,10 +57,10 @@ class JDBCDataRowEnumeratorTest {
JDBCDataRowEnumerator enumerator = new
JDBCDataRowEnumerator(firstQueryResult, firstMetaData,
Arrays.asList(firstStatement, secondStatement));
assertTrue(enumerator.moveNext());
Object actualRow = enumerator.current();
- assertThat(actualRow, instanceOf(Object[].class));
+ assertThat(actualRow, isA(Object[].class));
Object[] actualRowValues = (Object[]) actualRow;
assertThat(actualRowValues.length, is(2));
- assertThat(actualRowValues[0], instanceOf(Timestamp.class));
+ assertThat(actualRowValues[0], isA(Timestamp.class));
assertThat(actualRowValues[0],
is(Timestamp.valueOf(expectedDateTime)));
assertThat(actualRowValues[1], is("bar_value"));
assertFalse(enumerator.moveNext());
diff --git
a/kernel/sql-federation/executor/src/test/java/org/apache/shardingsphere/sqlfederation/executor/enumerable/enumerator/memory/MemoryDataRowEnumeratorTest.java
b/kernel/sql-federation/executor/src/test/java/org/apache/shardingsphere/sqlfederation/executor/enumerable/enumerator/memory/MemoryDataRowEnumeratorTest.java
index 48847dc815c..06ffeb538e1 100644
---
a/kernel/sql-federation/executor/src/test/java/org/apache/shardingsphere/sqlfederation/executor/enumerable/enumerator/memory/MemoryDataRowEnumeratorTest.java
+++
b/kernel/sql-federation/executor/src/test/java/org/apache/shardingsphere/sqlfederation/executor/enumerable/enumerator/memory/MemoryDataRowEnumeratorTest.java
@@ -29,7 +29,7 @@ import java.util.Collection;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.arrayContaining;
-import static org.hamcrest.Matchers.instanceOf;
+import static org.hamcrest.Matchers.isA;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
@@ -50,7 +50,7 @@ class MemoryDataRowEnumeratorTest {
assertNull(enumerator.current());
assertTrue(enumerator.moveNext());
Object firstRow = enumerator.current();
- assertThat(firstRow, instanceOf(Object[].class));
+ assertThat(firstRow, isA(Object[].class));
assertThat((Object[]) firstRow, arrayContaining(1, "foo_name"));
assertTrue(enumerator.moveNext());
assertThat((Object[]) enumerator.current(), arrayContaining(2,
"bar_name"));
diff --git
a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/connector/StandardDatabaseProxyConnectorTest.java
b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/connector/StandardDatabaseProxyConnectorTest.java
index 178ec4e8a74..391776b8719 100644
---
a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/connector/StandardDatabaseProxyConnectorTest.java
+++
b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/connector/StandardDatabaseProxyConnectorTest.java
@@ -117,9 +117,9 @@ import java.util.Properties;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
-import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.isA;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
@@ -226,7 +226,7 @@ class StandardDatabaseProxyConnectorTest {
try (
MockedConstruction<FederationMetaDataRefreshEngine>
mockedConstruction = mockConstruction(FederationMetaDataRefreshEngine.class,
(mock, context) ->
when(mock.isNeedRefresh()).thenReturn(true))) {
- assertThat(engine.execute(),
instanceOf(UpdateResponseHeader.class));
+ assertThat(engine.execute(), isA(UpdateResponseHeader.class));
FederationMetaDataRefreshEngine federationMetaDataRefreshEngine =
mockedConstruction.constructed().iterator().next();
verify(federationMetaDataRefreshEngine).refresh(any(),
any(ShardingSphereDatabase.class));
}
@@ -252,7 +252,7 @@ class StandardDatabaseProxyConnectorTest {
MockedConstruction<ProxyBackendTransactionManager>
mockedTransactionManager =
mockConstruction(ProxyBackendTransactionManager.class);
MockedStatic<ShardingSphereServiceLoader> serviceLoader =
mockStatic(ShardingSphereServiceLoader.class)) {
serviceLoader.when(() ->
ShardingSphereServiceLoader.getServiceInstances(AdvancedProxySQLExecutor.class)).thenReturn(Collections.emptyList());
- assertThat(engine.execute(),
instanceOf(UpdateResponseHeader.class));
+ assertThat(engine.execute(), isA(UpdateResponseHeader.class));
assertThat(mockedKernelProcessor.constructed().size(), is(1));
assertThat(mockedDatabaseTypeRegistry.constructed().size(), is(1));
ProxyBackendTransactionManager transactionManager =
mockedTransactionManager.constructed().iterator().next();
@@ -444,7 +444,7 @@ class StandardDatabaseProxyConnectorTest {
});
spiLoader.when(() ->
DatabaseTypedSPILoader.getService(eq(QueryHeaderBuilder.class),
any(DatabaseType.class))).thenReturn(new QueryHeaderBuilderFixture());
spiLoader.when(() ->
DatabaseTypedSPILoader.getService(QueryHeaderBuilder.class,
null)).thenReturn(new QueryHeaderBuilderFixture());
- assertThat(engine.execute(),
instanceOf(QueryResponseHeader.class));
+ assertThat(engine.execute(), isA(QueryResponseHeader.class));
}
}
@@ -465,7 +465,7 @@ class StandardDatabaseProxyConnectorTest {
setField(engine, "proxySQLExecutor", proxySQLExecutor);
try (MockedStatic<DatabaseTypedSPILoader> spiLoader =
mockStatic(DatabaseTypedSPILoader.class)) {
spiLoader.when(() ->
DatabaseTypedSPILoader.getService(eq(QueryHeaderBuilder.class),
any(DatabaseType.class))).thenReturn(new QueryHeaderBuilderFixture());
- assertThat(engine.execute(),
instanceOf(QueryResponseHeader.class));
+ assertThat(engine.execute(), isA(QueryResponseHeader.class));
}
}
@@ -487,7 +487,7 @@ class StandardDatabaseProxyConnectorTest {
(mock, context) ->
when(mock.isNeedRefresh()).thenReturn(false));
MockedConstruction<KernelProcessor> mockedKernelProcessor =
mockConstruction(KernelProcessor.class,
(mock, context) ->
when(mock.generateExecutionContext(any(QueryContext.class),
any(RuleMetaData.class),
any(ConfigurationProperties.class))).thenReturn(executionContext))) {
- assertThat(engine.execute(),
instanceOf(UpdateResponseHeader.class));
+ assertThat(engine.execute(), isA(UpdateResponseHeader.class));
assertThat(mockedRefreshEngine.constructed().size(), is(1));
assertThat(mockedKernelProcessor.constructed().size(), is(1));
}
@@ -527,7 +527,7 @@ class StandardDatabaseProxyConnectorTest {
MockedStatic<ShardingSphereServiceLoader> serviceLoader =
mockStatic(ShardingSphereServiceLoader.class)) {
spiLoader.when(() ->
DatabaseTypedSPILoader.getService(eq(QueryHeaderBuilder.class),
any(DatabaseType.class))).thenReturn(new QueryHeaderBuilderFixture());
serviceLoader.when(() ->
ShardingSphereServiceLoader.getServiceInstances(AdvancedProxySQLExecutor.class)).thenReturn(Collections.emptyList());
- assertThat(engine.execute(),
instanceOf(QueryResponseHeader.class));
+ assertThat(engine.execute(), isA(QueryResponseHeader.class));
assertThat(mockedKernelProcessor.constructed().size(), is(1));
assertThat(mockedDatabaseTypeRegistry.constructed().size(), is(1));
assertThat(mockedMergeEngine.constructed().size(), is(1));
@@ -576,7 +576,7 @@ class StandardDatabaseProxyConnectorTest {
MockedStatic<ShardingSphereServiceLoader> serviceLoader =
mockStatic(ShardingSphereServiceLoader.class)) {
spiLoader.when(() ->
DatabaseTypedSPILoader.getService(eq(QueryHeaderBuilder.class),
any(DatabaseType.class))).thenReturn(new QueryHeaderBuilderFixture());
serviceLoader.when(() ->
ShardingSphereServiceLoader.getServiceInstances(AdvancedProxySQLExecutor.class)).thenReturn(Collections.emptyList());
- assertThat(engine.execute(),
instanceOf(QueryResponseHeader.class));
+ assertThat(engine.execute(), isA(QueryResponseHeader.class));
assertThat(mockedKernelProcessor.constructed().size(), is(1));
assertThat(mockedDatabaseTypeRegistry.constructed().size(), is(1));
assertThat(mockedMergeEngine.constructed().size(), is(1));
@@ -608,7 +608,7 @@ class StandardDatabaseProxyConnectorTest {
MockedConstruction<ProxyBackendTransactionManager>
mockedTransactionManager =
mockConstruction(ProxyBackendTransactionManager.class);
MockedStatic<ShardingSphereServiceLoader> serviceLoader =
mockStatic(ShardingSphereServiceLoader.class)) {
serviceLoader.when(() ->
ShardingSphereServiceLoader.getServiceInstances(AdvancedProxySQLExecutor.class)).thenReturn(Collections.emptyList());
- assertThat(engine.execute(),
instanceOf(UpdateResponseHeader.class));
+ assertThat(engine.execute(), isA(UpdateResponseHeader.class));
assertThat(mockedKernelProcessor.constructed().size(), is(1));
assertThat(mockedDatabaseTypeRegistry.constructed().size(), is(1));
verify(mockedTransactionManager.constructed().iterator().next()).commit();
@@ -645,31 +645,31 @@ class StandardDatabaseProxyConnectorTest {
@Test
void assertExecuteWithoutImplicitCommitWhenSingleExecutionUnit() throws
SQLException {
InsertStatement insertStatement = new InsertStatement(databaseType);
- assertThat(executeWithImplicitCommitCondition(insertStatement, "XA",
false, 1), instanceOf(UpdateResponseHeader.class));
+ assertThat(executeWithImplicitCommitCondition(insertStatement, "XA",
false, 1), isA(UpdateResponseHeader.class));
}
@Test
void assertExecuteWithoutImplicitCommitWhenLocalTransaction() throws
SQLException {
InsertStatement insertStatement = new InsertStatement(databaseType);
- assertThat(executeWithImplicitCommitCondition(insertStatement,
"LOCAL", false, 2), instanceOf(UpdateResponseHeader.class));
+ assertThat(executeWithImplicitCommitCondition(insertStatement,
"LOCAL", false, 2), isA(UpdateResponseHeader.class));
}
@Test
void assertExecuteWithoutImplicitCommitWhenAlreadyInTransaction() throws
SQLException {
InsertStatement insertStatement = new InsertStatement(databaseType);
- assertThat(executeWithImplicitCommitCondition(insertStatement, "XA",
true, 2), instanceOf(UpdateResponseHeader.class));
+ assertThat(executeWithImplicitCommitCondition(insertStatement, "XA",
true, 2), isA(UpdateResponseHeader.class));
}
@Test
void assertExecuteWithoutImplicitCommitWhenSelectStatement() throws
SQLException {
SelectStatement selectStatement = new SelectStatement(databaseType);
- assertThat(executeWithImplicitCommitCondition(selectStatement, "XA",
false, 2), instanceOf(UpdateResponseHeader.class));
+ assertThat(executeWithImplicitCommitCondition(selectStatement, "XA",
false, 2), isA(UpdateResponseHeader.class));
}
@Test
void assertExecuteWithoutImplicitCommitWhenSQLStatementIsNotDML() throws
SQLException {
SQLStatement sqlStatement = new SQLStatement(databaseType);
- assertThat(executeWithImplicitCommitCondition(sqlStatement, "XA",
false, 2), instanceOf(UpdateResponseHeader.class));
+ assertThat(executeWithImplicitCommitCondition(sqlStatement, "XA",
false, 2), isA(UpdateResponseHeader.class));
}
@Test
@@ -692,7 +692,7 @@ class StandardDatabaseProxyConnectorTest {
MockedConstruction<ProxyBackendTransactionManager>
mockedTransactionManager =
mockConstruction(ProxyBackendTransactionManager.class);
MockedStatic<ShardingSphereServiceLoader> serviceLoader =
mockStatic(ShardingSphereServiceLoader.class)) {
serviceLoader.when(() ->
ShardingSphereServiceLoader.getServiceInstances(AdvancedProxySQLExecutor.class)).thenReturn(Collections.emptyList());
- assertThat(engine.execute(),
instanceOf(UpdateResponseHeader.class));
+ assertThat(engine.execute(), isA(UpdateResponseHeader.class));
assertThat(mockedKernelProcessor.constructed().size(), is(1));
assertThat(mockedDatabaseTypeRegistry.constructed().size(), is(1));
assertTrue(mockedTransactionManager.constructed().isEmpty());
diff --git
a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/connector/jdbc/executor/callback/ProxyJDBCExecutorCallbackFactoryTest.java
b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/connector/jdbc/executor/callback/ProxyJDBCExecutorCallbackFactoryTest.java
index b9c66c4924d..69d929a9484 100644
---
a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/connector/jdbc/executor/callback/ProxyJDBCExecutorCallbackFactoryTest.java
+++
b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/connector/jdbc/executor/callback/ProxyJDBCExecutorCallbackFactoryTest.java
@@ -23,9 +23,9 @@ import
org.apache.shardingsphere.proxy.backend.connector.jdbc.executor.callback.
import
org.apache.shardingsphere.proxy.backend.connector.jdbc.executor.callback.impl.ProxyStatementExecutorCallback;
import org.junit.jupiter.api.Test;
-import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.isA;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.Mockito.mock;
@@ -34,13 +34,13 @@ class ProxyJDBCExecutorCallbackFactoryTest {
@Test
void assertNewInstanceWithStatementDriverType() {
ProxyJDBCExecutorCallback actual =
ProxyJDBCExecutorCallbackFactory.newInstance(JDBCDriverType.STATEMENT, mock(),
mock(), mock(), mock(), true, true, true);
- assertThat(actual, instanceOf(ProxyStatementExecutorCallback.class));
+ assertThat(actual, isA(ProxyStatementExecutorCallback.class));
}
@Test
void assertNewInstanceWithPreparedStatementDriverType() {
ProxyJDBCExecutorCallback actual =
ProxyJDBCExecutorCallbackFactory.newInstance(JDBCDriverType.PREPARED_STATEMENT,
mock(), mock(), mock(), mock(), false, false, false);
- assertThat(actual,
instanceOf(ProxyPreparedStatementExecutorCallback.class));
+ assertThat(actual, isA(ProxyPreparedStatementExecutorCallback.class));
}
@Test
diff --git
a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/tcl/local/type/CommitProxyBackendHandlerTest.java
b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/tcl/local/type/CommitProxyBackendHandlerTest.java
index fc4b946407c..55f9b8c3220 100644
---
a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/tcl/local/type/CommitProxyBackendHandlerTest.java
+++
b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/tcl/local/type/CommitProxyBackendHandlerTest.java
@@ -37,9 +37,9 @@ import java.sql.Connection;
import java.sql.SQLException;
import java.util.Collections;
-import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.isA;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.mockConstruction;
import static org.mockito.Mockito.mockStatic;
@@ -67,7 +67,7 @@ class CommitProxyBackendHandlerTest {
ResponseHeader actual = new
CommitProxyBackendHandler(sqlStatement, connectionSession).execute();
ProxyBackendTransactionManager transactionManager =
mockedConstruction.constructed().get(0);
verify(transactionManager).commit();
- assertThat(((UpdateResponseHeader) actual).getSqlStatement(),
instanceOf(RollbackStatement.class));
+ assertThat(((UpdateResponseHeader) actual).getSqlStatement(),
isA(RollbackStatement.class));
}
}
diff --git
a/proxy/backend/dialect/firebird/src/test/java/org/apache/shardingsphere/proxy/backend/firebird/handler/admin/FirebirdAdminExecutorCreatorTest.java
b/proxy/backend/dialect/firebird/src/test/java/org/apache/shardingsphere/proxy/backend/firebird/handler/admin/FirebirdAdminExecutorCreatorTest.java
index 94d20742cbd..269eeda08ac 100644
---
a/proxy/backend/dialect/firebird/src/test/java/org/apache/shardingsphere/proxy/backend/firebird/handler/admin/FirebirdAdminExecutorCreatorTest.java
+++
b/proxy/backend/dialect/firebird/src/test/java/org/apache/shardingsphere/proxy/backend/firebird/handler/admin/FirebirdAdminExecutorCreatorTest.java
@@ -55,14 +55,14 @@ class FirebirdAdminExecutorCreatorTest {
@ParameterizedTest(name = "{0}")
@MethodSource("createArguments")
- void assertCreate(final String scenario, final SQLStatementContext
sqlStatementContext, final String sql, final Class<? extends
DatabaseAdminExecutor> expectedExecutorType) {
+ void assertCreate(final String name, final SQLStatementContext
sqlStatementContext, final String sql, final Class<? extends
DatabaseAdminExecutor> expectedExecutorType) {
final Optional<DatabaseAdminExecutor> actual =
creator.create(sqlStatementContext, sql, "", Collections.emptyList());
if (null == expectedExecutorType) {
- assertFalse(actual.isPresent(), scenario);
- return;
+ assertFalse(actual.isPresent(), name);
+ } else {
+ assertTrue(actual.isPresent(), name);
+ assertThat(actual.get(), isA(expectedExecutorType));
}
- assertTrue(actual.isPresent(), scenario);
- assertThat(actual.get(), isA(expectedExecutorType));
}
private static Stream<Arguments> createArguments() {
diff --git
a/proxy/backend/dialect/mysql/src/test/java/org/apache/shardingsphere/proxy/backend/mysql/handler/admin/factory/MySQLShowAdminExecutorFactoryTest.java
b/proxy/backend/dialect/mysql/src/test/java/org/apache/shardingsphere/proxy/backend/mysql/handler/admin/factory/MySQLShowAdminExecutorFactoryTest.java
index abc759c9a61..31a8317f0be 100644
---
a/proxy/backend/dialect/mysql/src/test/java/org/apache/shardingsphere/proxy/backend/mysql/handler/admin/factory/MySQLShowAdminExecutorFactoryTest.java
+++
b/proxy/backend/dialect/mysql/src/test/java/org/apache/shardingsphere/proxy/backend/mysql/handler/admin/factory/MySQLShowAdminExecutorFactoryTest.java
@@ -39,8 +39,8 @@ import org.junit.jupiter.params.provider.MethodSource;
import java.util.Optional;
import java.util.stream.Stream;
-import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.isA;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.Mockito.mock;
@@ -52,7 +52,7 @@ class MySQLShowAdminExecutorFactoryTest {
void assertCreateExecutor(final String caseName, final SQLStatement
statement, final Class<? extends DatabaseAdminExecutor> expectedType) {
Optional<DatabaseAdminExecutor> actual =
MySQLShowAdminExecutorFactory.newInstance(statement);
assertTrue(actual.isPresent(), caseName);
- assertThat(actual.get(), instanceOf(expectedType));
+ assertThat(actual.get(), isA(expectedType));
}
@Test
diff --git
a/proxy/backend/dialect/mysql/src/test/java/org/apache/shardingsphere/proxy/backend/mysql/handler/admin/factory/withoutfrom/MySQLSelectWithoutFromAdminExecutorFactoryTest.java
b/proxy/backend/dialect/mysql/src/test/java/org/apache/shardingsphere/proxy/backend/mysql/handler/admin/factory/withoutfrom/MySQLSelectWithoutFromAdminExecutorFactoryTest.java
index 464da229b52..274358b581f 100644
---
a/proxy/backend/dialect/mysql/src/test/java/org/apache/shardingsphere/proxy/backend/mysql/handler/admin/factory/withoutfrom/MySQLSelectWithoutFromAdminExecutorFactoryTest.java
+++
b/proxy/backend/dialect/mysql/src/test/java/org/apache/shardingsphere/proxy/backend/mysql/handler/admin/factory/withoutfrom/MySQLSelectWithoutFromAdminExecutorFactoryTest.java
@@ -40,8 +40,8 @@ import java.util.Arrays;
import java.util.Collections;
import java.util.Optional;
-import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.isA;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.Mockito.mock;
@@ -57,7 +57,7 @@ class MySQLSelectWithoutFromAdminExecutorFactoryTest {
Optional<DatabaseAdminExecutor> actual =
MySQLSelectWithoutFromAdminExecutorFactory.newInstance(
mockSelectStatementContext(selectStatement), "", null,
mock(ShardingSphereMetaData.class));
assertTrue(actual.isPresent());
- assertThat(actual.get(),
instanceOf(MySQLSystemVariableQueryExecutor.class));
+ assertThat(actual.get(), isA(MySQLSystemVariableQueryExecutor.class));
}
@Test
@@ -66,7 +66,7 @@ class MySQLSelectWithoutFromAdminExecutorFactoryTest {
Optional<DatabaseAdminExecutor> actual =
MySQLSelectWithoutFromAdminExecutorFactory.newInstance(
mockSelectStatementContext(selectStatement), "", null,
mock(ShardingSphereMetaData.class));
assertTrue(actual.isPresent());
- assertThat(actual.get(), instanceOf(ShowConnectionIdExecutor.class));
+ assertThat(actual.get(), isA(ShowConnectionIdExecutor.class));
}
@Test
@@ -75,7 +75,7 @@ class MySQLSelectWithoutFromAdminExecutorFactoryTest {
Optional<DatabaseAdminExecutor> actual =
MySQLSelectWithoutFromAdminExecutorFactory.newInstance(
mockSelectStatementContext(selectStatement), "", null,
mock(ShardingSphereMetaData.class));
assertTrue(actual.isPresent());
- assertThat(actual.get(), instanceOf(ShowVersionExecutor.class));
+ assertThat(actual.get(), isA(ShowVersionExecutor.class));
}
@Test
@@ -84,7 +84,7 @@ class MySQLSelectWithoutFromAdminExecutorFactoryTest {
Optional<DatabaseAdminExecutor> actual =
MySQLSelectWithoutFromAdminExecutorFactory.newInstance(
mockSelectStatementContext(selectStatement), "", null,
mock(ShardingSphereMetaData.class));
assertTrue(actual.isPresent());
- assertThat(actual.get(), instanceOf(ShowCurrentUserExecutor.class));
+ assertThat(actual.get(), isA(ShowCurrentUserExecutor.class));
}
@Test
@@ -93,7 +93,7 @@ class MySQLSelectWithoutFromAdminExecutorFactoryTest {
Optional<DatabaseAdminExecutor> actual =
MySQLSelectWithoutFromAdminExecutorFactory.newInstance(
mockSelectStatementContext(selectStatement), "", null,
mock(ShardingSphereMetaData.class));
assertTrue(actual.isPresent());
- assertThat(actual.get(),
instanceOf(ShowCurrentDatabaseExecutor.class));
+ assertThat(actual.get(), isA(ShowCurrentDatabaseExecutor.class));
}
@Test
@@ -104,7 +104,7 @@ class MySQLSelectWithoutFromAdminExecutorFactoryTest {
Optional<DatabaseAdminExecutor> actual =
MySQLSelectWithoutFromAdminExecutorFactory.newInstance(
mockSelectStatementContext(selectStatement), "", null,
metaData);
assertTrue(actual.isPresent());
- assertThat(actual.get(), instanceOf(NoResourceShowExecutor.class));
+ assertThat(actual.get(), isA(NoResourceShowExecutor.class));
}
@Test
@@ -129,7 +129,7 @@ class MySQLSelectWithoutFromAdminExecutorFactoryTest {
when(metaData.getAllDatabases()).thenReturn(Collections.singletonList(database));
Optional<DatabaseAdminExecutor> actual =
MySQLSelectWithoutFromAdminExecutorFactory.newInstance(mockSelectStatementContext(selectStatement),
"", null, metaData);
assertTrue(actual.isPresent());
- assertThat(actual.get(),
instanceOf(UnicastResourceShowExecutor.class));
+ assertThat(actual.get(), isA(UnicastResourceShowExecutor.class));
}
@Test
@@ -152,7 +152,7 @@ class MySQLSelectWithoutFromAdminExecutorFactoryTest {
Optional<DatabaseAdminExecutor> actual =
MySQLSelectWithoutFromAdminExecutorFactory.newInstance(
mockSelectStatementContext(selectStatement), "", null,
metaData);
assertTrue(actual.isPresent());
- assertThat(actual.get(),
instanceOf(UnicastResourceShowExecutor.class));
+ assertThat(actual.get(), isA(UnicastResourceShowExecutor.class));
}
@Test
@@ -162,7 +162,7 @@ class MySQLSelectWithoutFromAdminExecutorFactoryTest {
Optional<DatabaseAdminExecutor> actual =
MySQLSelectWithoutFromAdminExecutorFactory.newInstance(
mockSelectStatementContext(selectStatement), "", null,
mock(ShardingSphereMetaData.class));
assertTrue(actual.isPresent());
- assertThat(actual.get(), instanceOf(ShowCurrentUserExecutor.class));
+ assertThat(actual.get(), isA(ShowCurrentUserExecutor.class));
}
private SelectStatement createSelectStatement(final
Iterable<ProjectionSegment> projections) {
diff --git
a/test/it/pipeline/src/test/java/org/apache/shardingsphere/data/pipeline/scenario/consistencycheck/ConsistencyCheckJobExecutorCallbackTest.java
b/test/it/pipeline/src/test/java/org/apache/shardingsphere/data/pipeline/scenario/consistencycheck/ConsistencyCheckJobExecutorCallbackTest.java
index dd50df7332c..81a61fec598 100644
---
a/test/it/pipeline/src/test/java/org/apache/shardingsphere/data/pipeline/scenario/consistencycheck/ConsistencyCheckJobExecutorCallbackTest.java
+++
b/test/it/pipeline/src/test/java/org/apache/shardingsphere/data/pipeline/scenario/consistencycheck/ConsistencyCheckJobExecutorCallbackTest.java
@@ -27,7 +27,6 @@ import
org.apache.shardingsphere.data.pipeline.core.job.id.PipelineJobIdUtils;
import
org.apache.shardingsphere.data.pipeline.core.job.progress.ConsistencyCheckJobItemProgress;
import
org.apache.shardingsphere.data.pipeline.core.job.progress.yaml.config.YamlConsistencyCheckJobItemProgress;
import
org.apache.shardingsphere.data.pipeline.core.job.service.PipelineJobItemManager;
-import
org.apache.shardingsphere.data.pipeline.core.task.runner.PipelineTasksRunner;
import
org.apache.shardingsphere.data.pipeline.scenario.consistencycheck.config.ConsistencyCheckJobConfiguration;
import
org.apache.shardingsphere.data.pipeline.scenario.consistencycheck.config.yaml.config.YamlConsistencyCheckJobConfiguration;
import
org.apache.shardingsphere.data.pipeline.scenario.consistencycheck.config.yaml.swapper.YamlConsistencyCheckJobConfigurationSwapper;
@@ -49,8 +48,8 @@ import java.util.Properties;
import java.util.stream.Collectors;
import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.Matchers.instanceOf;
import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.isA;
import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
import static org.mockito.Mockito.mock;
@@ -87,8 +86,7 @@ class ConsistencyCheckJobExecutorCallbackTest {
@Test
void assertBuildTasksRunner() {
ConsistencyCheckJobConfiguration jobConfig = new
ConsistencyCheckJobConfiguration("check_job", "parent_job", "DATA_MATCH", new
Properties(), databaseType);
- PipelineTasksRunner actual = new
ConsistencyCheckJobExecutorCallback().buildTasksRunner(new
ConsistencyCheckJobItemContext(jobConfig, 0, JobStatus.RUNNING, null));
- assertThat(actual, instanceOf(ConsistencyCheckTasksRunner.class));
+ assertThat(new
ConsistencyCheckJobExecutorCallback().buildTasksRunner(new
ConsistencyCheckJobItemContext(jobConfig, 0, JobStatus.RUNNING, null)),
isA(ConsistencyCheckTasksRunner.class));
}
@Test
