You are viewing a plain text version of this content. The canonical link for it is here.
Posted to notifications@shardingsphere.apache.org by zh...@apache.org on 2026/03/12 15:57:15 UTC
(shardingsphere) branch master updated: Add more test cases on StandardIdentifierCaseRuleTest and IdentifierCaseRuleSetsTest (#38408)
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 fef48d7ef59 Add more test cases on StandardIdentifierCaseRuleTest and IdentifierCaseRuleSetsTest (#38408)
fef48d7ef59 is described below
commit fef48d7ef5901852289c7131aa99404687ba0f26
Author: Liang Zhang <zh...@apache.org>
AuthorDate: Thu Mar 12 23:57:06 2026 +0800
Add more test cases on StandardIdentifierCaseRuleTest and IdentifierCaseRuleSetsTest (#38408)
* Add more test cases on StandardIdentifierCaseRuleTest and IdentifierCaseRuleSetsTest
* Add more test cases on StandardIdentifierCaseRuleTest and IdentifierCaseRuleSetsTest
---
.../identifier/IdentifierCaseRuleSetsTest.java | 89 ++++++++++++++++++++++
.../identifier/StandardIdentifierCaseRuleTest.java | 53 +++++++------
2 files changed, 115 insertions(+), 27 deletions(-)
diff --git a/database/connector/core/src/test/java/org/apache/shardingsphere/database/connector/core/metadata/identifier/IdentifierCaseRuleSetsTest.java b/database/connector/core/src/test/java/org/apache/shardingsphere/database/connector/core/metadata/identifier/IdentifierCaseRuleSetsTest.java
new file mode 100644
index 00000000000..5fc10c2263a
--- /dev/null
+++ b/database/connector/core/src/test/java/org/apache/shardingsphere/database/connector/core/metadata/identifier/IdentifierCaseRuleSetsTest.java
@@ -0,0 +1,89 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.shardingsphere.database.connector.core.metadata.identifier;
+
+import org.apache.shardingsphere.database.connector.core.metadata.database.enums.QuoteCharacter;
+import org.apache.shardingsphere.database.connector.core.metadata.database.metadata.option.IdentifierPatternType;
+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.util.stream.Stream;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class IdentifierCaseRuleSetsTest {
+
+ @Test
+ void assertNewLowerCaseRuleSet() {
+ IdentifierCaseRule actual = IdentifierCaseRuleSets.newLowerCaseRuleSet().getRule(IdentifierScope.TABLE);
+ assertThat(actual.normalize("Foo"), is("foo"));
+ assertFalse(actual.matches("Foo", "FOO", QuoteCharacter.NONE));
+ }
+
+ @Test
+ void assertNewUpperCaseRuleSet() {
+ IdentifierCaseRule actual = IdentifierCaseRuleSets.newUpperCaseRuleSet().getRule(IdentifierScope.TABLE);
+ assertThat(actual.normalize("Foo"), is("FOO"));
+ assertFalse(actual.matches("Foo", "foo", QuoteCharacter.NONE));
+ }
+
+ @Test
+ void assertNewSensitiveRuleSet() {
+ IdentifierCaseRule actual = IdentifierCaseRuleSets.newSensitiveRuleSet().getRule(IdentifierScope.TABLE);
+ assertThat(actual.getLookupMode(QuoteCharacter.NONE), is(LookupMode.EXACT));
+ assertFalse(actual.matches("Foo", "foo", QuoteCharacter.NONE));
+ }
+
+ @Test
+ void assertNewInsensitiveRuleSet() {
+ IdentifierCaseRule actual = IdentifierCaseRuleSets.newInsensitiveRuleSet().getRule(IdentifierScope.TABLE);
+ assertThat(actual.getLookupMode(QuoteCharacter.QUOTE), is(LookupMode.EXACT));
+ assertTrue(actual.matches("Foo", "FOO", QuoteCharacter.NONE));
+ }
+
+ @Test
+ void assertNewMySQLInsensitiveRuleSet() {
+ IdentifierCaseRule actual = IdentifierCaseRuleSets.newMySQLInsensitiveRuleSet().getRule(IdentifierScope.TABLE);
+ assertThat(actual.getLookupMode(QuoteCharacter.QUOTE), is(LookupMode.NORMALIZED));
+ assertThat(actual.getLookupMode(QuoteCharacter.NONE), is(LookupMode.NORMALIZED));
+ }
+
+ @ParameterizedTest(name = "{0}")
+ @MethodSource("newDialectDefaultRuleSetArguments")
+ void assertNewDialectDefaultRuleSet(final String name, final IdentifierPatternType identifierPatternType, final boolean caseSensitive,
+ final LookupMode expectedQuotedLookupMode, final LookupMode expectedUnquotedLookupMode,
+ final String storedName, final String actualIdentifier, final boolean expected) {
+ IdentifierCaseRule actual = IdentifierCaseRuleSets.newDialectDefaultRuleSet(identifierPatternType, caseSensitive).getRule(IdentifierScope.TABLE);
+ assertThat(actual.getLookupMode(QuoteCharacter.QUOTE), is(expectedQuotedLookupMode));
+ assertThat(actual.getLookupMode(QuoteCharacter.NONE), is(expectedUnquotedLookupMode));
+ assertThat(actual.matches(storedName, actualIdentifier, QuoteCharacter.NONE), is(expected));
+ }
+
+ private static Stream<Arguments> newDialectDefaultRuleSetArguments() {
+ return Stream.of(
+ Arguments.of("lower_case", IdentifierPatternType.LOWER_CASE, false, LookupMode.EXACT, LookupMode.NORMALIZED, "foo", "FOO", true),
+ Arguments.of("upper_case", IdentifierPatternType.UPPER_CASE, false, LookupMode.EXACT, LookupMode.NORMALIZED, "FOO", "foo", true),
+ Arguments.of("keep_origin_sensitive", IdentifierPatternType.KEEP_ORIGIN, true, LookupMode.EXACT, LookupMode.EXACT, "Foo", "foo", false),
+ Arguments.of("keep_origin_insensitive", IdentifierPatternType.KEEP_ORIGIN, false, LookupMode.EXACT, LookupMode.NORMALIZED, "Foo", "FOO", true));
+ }
+}
diff --git a/database/connector/core/src/test/java/org/apache/shardingsphere/database/connector/core/metadata/identifier/StandardIdentifierCaseRuleTest.java b/database/connector/core/src/test/java/org/apache/shardingsphere/database/connector/core/metadata/identifier/StandardIdentifierCaseRuleTest.java
index 646b944fb28..b161063e559 100644
--- a/database/connector/core/src/test/java/org/apache/shardingsphere/database/connector/core/metadata/identifier/StandardIdentifierCaseRuleTest.java
+++ b/database/connector/core/src/test/java/org/apache/shardingsphere/database/connector/core/metadata/identifier/StandardIdentifierCaseRuleTest.java
@@ -19,57 +19,56 @@ package org.apache.shardingsphere.database.connector.core.metadata.identifier;
import org.apache.shardingsphere.database.connector.core.metadata.database.enums.QuoteCharacter;
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.util.Locale;
+import java.util.stream.Stream;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.is;
-import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertNull;
class StandardIdentifierCaseRuleTest {
+ private final StandardIdentifierCaseRule rule = new StandardIdentifierCaseRule(LookupMode.EXACT, LookupMode.NORMALIZED,
+ each -> each.toLowerCase(Locale.ENGLISH), each -> each.equals(each.toLowerCase(Locale.ENGLISH)));
+
@Test
void assertGetLookupModeWithQuotedIdentifier() {
- StandardIdentifierCaseRule rule = createPostgreSQLRule();
- LookupMode actualLookupMode = rule.getLookupMode(QuoteCharacter.QUOTE);
- assertThat(actualLookupMode, is(LookupMode.EXACT));
+ assertThat(rule.getLookupMode(QuoteCharacter.QUOTE), is(LookupMode.EXACT));
}
@Test
void assertGetLookupModeWithUnquotedIdentifier() {
- StandardIdentifierCaseRule rule = createPostgreSQLRule();
- LookupMode actualLookupMode = rule.getLookupMode(QuoteCharacter.NONE);
- assertThat(actualLookupMode, is(LookupMode.NORMALIZED));
+ assertThat(rule.getLookupMode(QuoteCharacter.NONE), is(LookupMode.NORMALIZED));
}
@Test
void assertNormalize() {
- StandardIdentifierCaseRule rule = createPostgreSQLRule();
- String actualValue = rule.normalize("Foo");
- assertThat(actualValue, is("foo"));
+ assertThat(rule.normalize("Foo"), is("foo"));
}
@Test
- void assertMatchesWithQuotedIdentifier() {
- StandardIdentifierCaseRule rule = createPostgreSQLRule();
- assertTrue(rule.matches("Foo", "Foo", QuoteCharacter.QUOTE));
+ void assertNormalizeWithNullValue() {
+ assertNull(rule.normalize(null));
}
- @Test
- void assertMatchesWithUnquotedIdentifier() {
- StandardIdentifierCaseRule rule = createPostgreSQLRule();
- assertTrue(rule.matches("foo", "FOO", QuoteCharacter.NONE));
- }
-
- @Test
- void assertNotMatchesWithUnquotedIdentifierForNonDefaultStoredName() {
- StandardIdentifierCaseRule rule = createPostgreSQLRule();
- assertFalse(rule.matches("Foo", "FOO", QuoteCharacter.NONE));
+ @ParameterizedTest(name = "{0}")
+ @MethodSource("matchesArguments")
+ void assertMatches(final String name, final String storedName, final String actualIdentifier, final QuoteCharacter quoteCharacter, final boolean expected) {
+ assertThat(rule.matches(storedName, actualIdentifier, quoteCharacter), is(expected));
}
- private StandardIdentifierCaseRule createPostgreSQLRule() {
- return new StandardIdentifierCaseRule(LookupMode.EXACT, LookupMode.NORMALIZED,
- each -> each.toLowerCase(Locale.ENGLISH), each -> each.equals(each.toLowerCase(Locale.ENGLISH)));
+ private static Stream<Arguments> matchesArguments() {
+ return Stream.of(
+ Arguments.of("quoted_match", "Foo", "Foo", QuoteCharacter.QUOTE, true),
+ Arguments.of("quoted_mismatch", "Foo", "foo", QuoteCharacter.QUOTE, false),
+ Arguments.of("unquoted_match", "foo", "FOO", QuoteCharacter.NONE, true),
+ Arguments.of("unquoted_non_default_stored_name", "Foo", "FOO", QuoteCharacter.NONE, false),
+ Arguments.of("unquoted_null_names", null, null, QuoteCharacter.NONE, true),
+ Arguments.of("unquoted_null_actual_identifier", "foo", null, QuoteCharacter.NONE, false),
+ Arguments.of("unquoted_different_actual_identifier", "foo", "bar", QuoteCharacter.NONE, false));
}
}