This is an automated email from the ASF dual-hosted git repository.
panjuan 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 8b0b0e6 Refactor ParameterizedArrayFactory (#8857)
8b0b0e6 is described below
commit 8b0b0e64f8f2191cc941f47986fddf0c4b8a18f6
Author: Liang Zhang <[email protected]>
AuthorDate: Fri Jan 1 22:38:08 2021 +0800
Refactor ParameterizedArrayFactory (#8857)
* Refactor ParameterizedArrayFactory
* Refactor ParameterizedArrayFactory
* Refactor ParameterizedArrayFactory
* Refactor ParameterizedArrayFactory
* Refactor ParameterizedArrayFactory
* Refactor ParameterizedArrayFactory
---
.../engine/param/ParameterizedArrayFactory.java | 105 ++++++---------------
1 file changed, 29 insertions(+), 76 deletions(-)
diff --git
a/shardingsphere-test/shardingsphere-integration-test/shardingsphere-test-suite/src/test/java/org/apache/shardingsphere/test/integration/engine/param/ParameterizedArrayFactory.java
b/shardingsphere-test/shardingsphere-integration-test/shardingsphere-test-suite/src/test/java/org/apache/shardingsphere/test/integration/engine/param/ParameterizedArrayFactory.java
index bb9afe5..2eaa1bb 100644
---
a/shardingsphere-test/shardingsphere-integration-test/shardingsphere-test-suite/src/test/java/org/apache/shardingsphere/test/integration/engine/param/ParameterizedArrayFactory.java
+++
b/shardingsphere-test/shardingsphere-integration-test/shardingsphere-test-suite/src/test/java/org/apache/shardingsphere/test/integration/engine/param/ParameterizedArrayFactory.java
@@ -17,12 +17,10 @@
package org.apache.shardingsphere.test.integration.engine.param;
-import com.google.common.base.Joiner;
import com.google.common.base.Splitter;
import com.google.common.base.Strings;
import lombok.AccessLevel;
import lombok.NoArgsConstructor;
-import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.apache.shardingsphere.infra.database.type.DatabaseType;
import org.apache.shardingsphere.infra.database.type.DatabaseTypeRegistry;
@@ -34,15 +32,10 @@ import
org.apache.shardingsphere.test.integration.engine.param.domain.AssertionP
import
org.apache.shardingsphere.test.integration.engine.param.domain.CaseParameterizedArray;
import
org.apache.shardingsphere.test.integration.engine.param.domain.ParameterizedArray;
import org.apache.shardingsphere.test.integration.env.IntegrateTestEnvironment;
-import org.junit.Test;
-import java.util.Arrays;
import java.util.Collection;
-import java.util.HashMap;
-import java.util.LinkedHashMap;
import java.util.LinkedList;
-import java.util.Map;
-import java.util.Map.Entry;
+import java.util.List;
import java.util.stream.Collectors;
/**
@@ -63,33 +56,19 @@ public final class ParameterizedArrayFactory {
* @return assertion parameterized array
*/
public static Collection<Object[]> getAssertionParameterizedArray(final
SQLCommandType sqlCommandType) {
- Map<DatabaseType, Collection<ParameterizedArray>> assertionParameters
= new LinkedHashMap<>(10, 1);
+ Collection<ParameterizedArray> result = new LinkedList<>();
for (IntegrateTestCaseContext each :
INTEGRATE_TEST_CASES_LOADER.getTestCaseContexts(sqlCommandType)) {
- Map<DatabaseType, Collection<ParameterizedArray>>
eachAssertionParameters = getAssertionParameterizedArray(each);
- for (Entry<DatabaseType, Collection<ParameterizedArray>> entry :
eachAssertionParameters.entrySet()) {
- assertionParameters.putIfAbsent(entry.getKey(), new
LinkedList<>());
-
assertionParameters.get(entry.getKey()).addAll(entry.getValue());
- }
- }
- Map<DatabaseType, Collection<ParameterizedArray>>
availableAssertionParameters = new LinkedHashMap<>(assertionParameters.size(),
1);
- Map<DatabaseType, Collection<ParameterizedArray>>
disabledAssertionParameters = new LinkedHashMap<>(assertionParameters.size(),
1);
- for (Entry<DatabaseType, Collection<ParameterizedArray>> entry :
assertionParameters.entrySet()) {
- if
(IntegrateTestEnvironment.getInstance().getDatabaseEnvironments().containsKey(entry.getKey()))
{
- availableAssertionParameters.put(entry.getKey(),
entry.getValue());
- } else {
- disabledAssertionParameters.put(entry.getKey(),
entry.getValue());
- }
+ result.addAll(getAssertionParameterizedArray(each));
}
- printTestPlan(availableAssertionParameters,
disabledAssertionParameters, calculateRunnableTestAnnotation());
- return
availableAssertionParameters.values().stream().flatMap(Collection::stream).map(ParameterizedArray::toArrays).collect(Collectors.toList());
+ return toArrays(result);
}
- private static Map<DatabaseType, Collection<ParameterizedArray>>
getAssertionParameterizedArray(final IntegrateTestCaseContext testCaseContext) {
- Collection<DatabaseType> databaseTypes =
getDatabaseTypes(testCaseContext.getTestCase().getDbTypes());
- Map<DatabaseType, Collection<ParameterizedArray>> result = new
HashMap<>(databaseTypes.size(), 1);
- for (DatabaseType each : databaseTypes) {
- result.putIfAbsent(each, new LinkedList<>());
-
result.get(each).addAll(getAssertionParameterizedArray(testCaseContext, each));
+ private static Collection<ParameterizedArray>
getAssertionParameterizedArray(final IntegrateTestCaseContext testCaseContext) {
+ Collection<ParameterizedArray> result = new LinkedList<>();
+ for (DatabaseType each :
getDatabaseTypes(testCaseContext.getTestCase().getDbTypes())) {
+ if
(IntegrateTestEnvironment.getInstance().getDatabaseEnvironments().containsKey(each))
{
+ result.addAll(getAssertionParameterizedArray(testCaseContext,
each));
+ }
}
return result;
}
@@ -102,12 +81,9 @@ public final class ParameterizedArrayFactory {
return result;
}
- private static Collection<ParameterizedArray>
getAssertionParameterizedArray(final IntegrateTestCaseContext testCaseContext,
final DatabaseType databaseType, final SQLExecuteType sqlExecuteType) {
+ private static Collection<ParameterizedArray>
getAssertionParameterizedArray(final IntegrateTestCaseContext testCaseContext,
+
final DatabaseType databaseType, final SQLExecuteType sqlExecuteType) {
Collection<ParameterizedArray> result = new LinkedList<>();
- if (testCaseContext.getTestCase().getAssertions().isEmpty()) {
- result.addAll(getAssertionParameterizedArray(testCaseContext,
null, databaseType, sqlExecuteType));
- return result;
- }
for (IntegrateTestCaseAssertion each :
testCaseContext.getTestCase().getAssertions()) {
result.addAll(getAssertionParameterizedArray(testCaseContext,
each, databaseType, sqlExecuteType));
}
@@ -127,22 +103,24 @@ public final class ParameterizedArrayFactory {
* @return case parameterized array
*/
public static Collection<Object[]> getCaseParameterizedArray(final
SQLCommandType sqlCommandType) {
- Map<DatabaseType, Collection<ParameterizedArray>> availableCases = new
LinkedHashMap<>();
- Map<DatabaseType, Collection<ParameterizedArray>> disabledCases = new
LinkedHashMap<>();
-
INTEGRATE_TEST_CASES_LOADER.getTestCaseContexts(sqlCommandType).forEach(testCaseContext
->
getDatabaseTypes(testCaseContext.getTestCase().getDbTypes()).forEach(databaseType
-> {
- if
(IntegrateTestEnvironment.getInstance().getDatabaseEnvironments().containsKey(databaseType))
{
- availableCases.putIfAbsent(databaseType, new LinkedList<>());
-
availableCases.get(databaseType).addAll(getCaseParameterizedArray(databaseType,
testCaseContext));
- } else {
- disabledCases.putIfAbsent(databaseType, new LinkedList<>());
-
disabledCases.get(databaseType).addAll(getCaseParameterizedArray(databaseType,
testCaseContext));
+ Collection<ParameterizedArray> result = new LinkedList<>();
+ for (IntegrateTestCaseContext each :
INTEGRATE_TEST_CASES_LOADER.getTestCaseContexts(sqlCommandType)) {
+ result.addAll(getCaseParameterizedArray(each));
+ }
+ return toArrays(result);
+ }
+
+ private static Collection<ParameterizedArray>
getCaseParameterizedArray(final IntegrateTestCaseContext testCaseContext) {
+ Collection<ParameterizedArray> result = new LinkedList<>();
+ for (DatabaseType each :
getDatabaseTypes(testCaseContext.getTestCase().getDbTypes())) {
+ if
(IntegrateTestEnvironment.getInstance().getDatabaseEnvironments().containsKey(each))
{
+ result.addAll(getCaseParameterizedArray(testCaseContext,
each));
}
- }));
- printTestPlan(availableCases, disabledCases,
calculateRunnableTestAnnotation());
- return
availableCases.values().stream().flatMap(Collection::stream).map(ParameterizedArray::toArrays).collect(Collectors.toList());
+ }
+ return result;
}
- private static Collection<ParameterizedArray>
getCaseParameterizedArray(final DatabaseType databaseType, final
IntegrateTestCaseContext testCaseContext) {
+ private static Collection<ParameterizedArray>
getCaseParameterizedArray(final IntegrateTestCaseContext testCaseContext, final
DatabaseType databaseType) {
return INTEGRATE_TEST_ENVIRONMENT.getScenarios().stream().map(each ->
new CaseParameterizedArray(testCaseContext, each,
databaseType)).collect(Collectors.toList());
}
@@ -151,32 +129,7 @@ public final class ParameterizedArrayFactory {
return
Splitter.on(',').trimResults().splitToList(candidates).stream().map(DatabaseTypeRegistry::getActualDatabaseType).collect(Collectors.toList());
}
- private static void printTestPlan(final Map<DatabaseType,
- Collection<ParameterizedArray>> availableCaseParameters, final
Map<DatabaseType, Collection<ParameterizedArray>> disabledCaseParameters, final
long factor) {
- Collection<String> activePlan = new LinkedList<>();
- for (Entry<DatabaseType, Collection<ParameterizedArray>> entry :
availableCaseParameters.entrySet()) {
- activePlan.add(String.format("%s(%s)", entry.getKey().getName(),
entry.getValue().size() * factor));
- }
- Collection<String> disabledPlan = new LinkedList<>();
- for (Entry<DatabaseType, Collection<ParameterizedArray>> entry :
disabledCaseParameters.entrySet()) {
- disabledPlan.add(String.format("%s(%s)", entry.getKey().getName(),
entry.getValue().size() * factor));
- }
- log.info("[INFO] ======= Test Plan =======");
- String summary = String.format("[%s] Total: %s, Active: %s, Disabled:
%s %s",
- disabledPlan.isEmpty() ? "INFO" : "WARN",
-
(availableCaseParameters.values().stream().mapToLong(Collection::size).sum() +
disabledCaseParameters.values().stream().mapToLong(Collection::size).sum()) *
factor,
- activePlan.isEmpty() ? 0 : Joiner.on(", ").join(activePlan),
disabledPlan.isEmpty() ? 0 : Joiner.on(", ").join(disabledPlan),
System.lineSeparator());
- log.info(summary);
- }
-
- @SneakyThrows(ReflectiveOperationException.class)
- private static long calculateRunnableTestAnnotation() {
- long result = 0;
- StackTraceElement[] stackTraceElements =
Thread.currentThread().getStackTrace();
- for (int i = 3; i < stackTraceElements.length; i++) {
- Class<?> callerClazz =
Class.forName(stackTraceElements[i].getClassName());
- result += Arrays.stream(callerClazz.getMethods()).filter(method ->
method.isAnnotationPresent(Test.class)).count();
- }
- return result;
+ private static List<Object[]> toArrays(final
Collection<ParameterizedArray> parameterizedArrays) {
+ return
parameterizedArrays.stream().map(ParameterizedArray::toArrays).collect(Collectors.toList());
}
}
