tests := []struct {
		input          string
		keys           []string
		expectedFields map[string]struct{}
	}{
		// No keys present
		{
			input:          "",
			keys:           []string{"comment"},
			expectedFields: map[string]struct{}{},
		},
		// No keys requested for tokenizing
		{
			input:          `comment="Hi this is my comment ="`,
			keys:           []string{},
			expectedFields: map[string]struct{}{},

            ModelCache modelCache, String groupId, String artifactId, String version, ModelCacheTag<T> tag, T data) {
        if (modelCache != null) {
            modelCache.put(groupId, artifactId, version, tag.getName(), tag.intoCache(data));
        }
    }

    private <T> T getCache(
            ModelCache modelCache, String groupId, String artifactId, String version, ModelCacheTag<T> tag) {

  public void testTransformEmptyMapEquality() {
    Map<String, String> map =
        transformValues(ImmutableMap.<String, Integer>of(), Functions.toStringFunction());
    assertMapsEqual(new HashMap<>(), map);
  }

  public void testTransformSingletonMapEquality() {
    Map<String, String> map =
        transformValues(ImmutableMap.of("a", 1), Functions.toStringFunction());
    Map<String, String> expected = ImmutableMap.of("a", "1");

  public static class ImmutableListMultimapGenerator extends TestStringListMultimapGenerator {
    @Override
    protected ListMultimap<String, String> create(Entry<String, String>[] entries) {
      ImmutableListMultimap.Builder<String, String> builder = ImmutableListMultimap.builder();
      for (Entry<String, String> entry : entries) {
        builder.put(entry.getKey(), entry.getValue());
      }
      return builder.build();
    }
  }

      Future<String> f = testExecutor.submit(doNothing(), RESULT_VALUE);
      mock.assertLastMethodCalled("submit");
      assertThat(f.get()).isEqualTo(RESULT_VALUE);
    }
    {
      MockExecutor mock = new MockExecutor();
      TestExecutor testExecutor = new TestExecutor(mock);
      Callable<String> task = Callables.returning(RESULT_VALUE);
      Future<String> f = testExecutor.submit(task);

        private String subject;
        private String plainText;

        public void setSubject(String subject) {
            this.subject = subject;
        }

        public void setPlainText(String plainText) {
            this.plainText = plainText;
        }

        @Override
        public OptionalThing<String> getSavedSubject() {

    protected static final String ID_TOKEN = "id_token";

    /** OAuth2 authorization code parameter name. */
    protected static final String CODE = "code";

    /** Timeout for token acquisition in milliseconds. */
    protected long acquisitionTimeout = 30 * 1000L;

    /** Cache for storing group information to reduce API calls. */
    protected Cache<String, Pair<String[], String[]>> groupCache;

    UnicodeEscaper spaceEscaper = new PercentEscaper(" ", false);

    assertThat(basicEscaper.escape("string with spaces")).isEqualTo("string%20with%20spaces");
    assertThat(plusForSpaceEscaper.escape("string with spaces")).isEqualTo("string+with+spaces");
    assertThat(spaceEscaper.escape("string with spaces")).isEqualTo("string with spaces");
  }

  /** Tests that if we add extra 'safe' characters they remain unescaped */

	}
}

func TestCreateOnConflictWithDefaultNull(t *testing.T) {
	type OnConflictUser struct {
		ID     string
		Name   string `gorm:"default:null"`
		Email  string
		Mobile string `gorm:"default:'133xxxx'"`
	}

	err := DB.Migrator().DropTable(&OnConflictUser{})
	AssertEqual(t, err, nil)
	err = DB.AutoMigrate(&OnConflictUser{})

    }

    /**
     * Creates a simple POM XML string for testing.
     *
     * @param groupId the group ID
     * @param artifactId the artifact ID
     * @param version the version
     * @return POM XML string
     */
    public static String createSimplePom(String groupId, String artifactId, String version) {
        return String.format("""
            <?xml version="1.0" encoding="UTF-8"?>