assertEquals("Extension for " + mimeType + " should be empty", "", generator.getExtensionFromMimeType(mimeType));
        }
    }

    // Test case sensitivity (current implementation is case-sensitive)
    @Test
    public void test_getExtensionFromMimeType_caseSensitive() {
        assertEquals("", generator.getExtensionFromMimeType("IMAGE/GIF"));

    }

    private int getKeyLength() {
        // Java 17 switch expression for cipher key length determination
        return switch (this.cipherId) {
        case CIPHER_AES_128_CCM, CIPHER_AES_128_GCM -> 16; // AES-128 ciphers use 16-byte keys
        case CIPHER_AES_256_CCM, CIPHER_AES_256_GCM -> 32; // AES-256 ciphers use 32-byte keys
        default -> throw new IllegalArgumentException("Unsupported cipher: " + this.cipherId);

@J2ktIncompatible
@GwtIncompatible
public abstract class Striped<L> {
  /**
   * If there are at least this many stripes, we assume the memory usage of a ConcurrentMap will be
   * smaller than a large array. (This assumes that in the lazy case, most stripes are unused. As
   * always, if many stripes are in use, a non-lazy striped makes more sense.)
   */
  private static final int LARGE_LAZY_CUTOFF = 1024;

  private Striped() {}

  /**

       * cause set to the underlying exception (which may be from another thread). If we someday
       * learn that some other exception besides IllegalArgumentException is common, then we could
       * add another special case to throw an instance of it, too.
       */
      throw e;
    }
  }

  private static ImmutableList<Method> getAnnotatedMethodsNotCached(Class<?> clazz) {

 * to the methods of the delegate. For example, overriding {@link #add} alone <i>will not</i> change
 * the behavior of {@link #addAll}, which can lead to unexpected behavior. In this case, you should
 * override {@code addAll} as well, either providing your own implementation, or delegating to the
 * provided {@code standardAddAll} method.
 *

        ALLOWS_NULL_KEYS);
  }

  /**
   * Map generator that verifies that {@code setUp()} methods are called in all the test cases. The
   * {@code setUpRan} parameter is set true by the {@code setUp} that every test case is supposed to
   * have registered, and set false by the {@code tearDown}. We use a dynamic proxy to intercept all
   * of the {@code Map} method calls and check that {@code setUpRan} is true.
   */

				"Birthday", "CompanyID", "ManagerID", "Active")
		}
	})
}

func tidbSkip(t *testing.T, reason string) {
	if isTiDB() {
		t.Skipf("This test case skipped, because of TiDB '%s'", reason)
	}
}

func isTiDB() bool {
	return os.Getenv("GORM_DIALECT") == "tidb"
}

func isMysql() bool {
	return os.Getenv("GORM_DIALECT") == "mysql"
}

        assertEquals(builder, result); // Test method chaining
        assertEquals("test_index", builder.settingsIndexName);

        // Test setting index name with mixed case
        builder.setSettingsIndexName("TeSt_InDeX_NaMe");
        assertEquals("test_index_name", builder.settingsIndexName);

        // Test setting index name that's already lowercase

   * observed contention rates are typically low in these cases.
   *
   * It is possible for a Cell to become unused when threads that
   * once hashed to it terminate, as well as in the case where
   * doubling the table causes no thread to hash to it under
   * expanded mask.  We do not try to detect or remove such cells,
   * under the assumption that for long-running instances, observed

	policyCondFailedErr := "Invalid according to Policy: Policy Condition failed"

	type testCase struct {
		name    string
		fv      formValues
		expired bool
		wantErr string
	}

	// Test case just contains fields we override from defaultFormVals.
	testCases := []testCase{
		{
			name:    "happy path no errors",
			fv:      defaultFormVals.Clone(),
			wantErr: "",
		},
		{