SharedTags: []Tag{
			{Locale: "ZH", Value: "tag1"},
			{Locale: "ZH", Value: "tag2"},
		},
	}
	DB.Save(&blog)

	blog2 := Blog{
		ID:     blog.ID,
		Locale: "EN",
	}
	DB.Create(&blog2)

	if !compareTags(blog.SharedTags, []string{"tag1", "tag2"}) {
		t.Fatalf("Blog should has two tags")
	}

	// Append
	tag3 := &Tag{Locale: "ZH", Value: "tag3"}

    }

    // PUT /api/admin/accesstoken/setting
    @Execute
    public JsonResponse<ApiResult> put$setting(final CreateBody body) {
        validateApi(body, messages -> {});
        body.crudMode = CrudMode.CREATE;
        final AccessToken accessToken = getAccessToken(body).map(entity -> {
            entity.setToken(accessTokenHelper.generateAccessToken());
            try {
                accessTokenService.store(entity);

        if (!isValidWebConfigId(body.webConfigId)) {
            return asJson(new ApiErrorResponse().message("invalid webConfigId").status(Status.BAD_REQUEST).result());
        }

        body.crudMode = CrudMode.CREATE;
        final RequestHeader reqHeader = getRequestHeader(body).map(entity -> {
            try {
                reqHeaderService.store(entity);
            } catch (final Exception e) {

        if (!isValidWebConfigId(body.webConfigId)) {
            return asJson(new ApiErrorResponse().message("invalid webConfigId").status(Status.BAD_REQUEST).result());
        }

        body.crudMode = CrudMode.CREATE;
        final WebAuthentication webAuth = getWebAuthentication(body).map(entity -> {
            try {
                webAuthService.store(entity);
            } catch (final Exception e) {

import java.util.concurrent.TimeUnit
import mockwebserver3.Stream
import mockwebserver3.StreamHandler
import okio.utf8Size

private typealias Action = (Stream) -> Unit

/**
 * A scriptable request/response conversation. Create the script by calling methods like
 * [receiveRequest] in the sequence they are run.
 */
class MockStreamHandler : StreamHandler {
  private val actions = LinkedBlockingQueue<Action>()

		kmsRouter.Methods(http.MethodGet).Path(version + "/version").HandlerFunc(gz(httpTraceAll(kmsAPI.KMSVersionHandler)))
		// KMS Key APIs
		kmsRouter.Methods(http.MethodPost).Path(version+"/key/create").HandlerFunc(gz(httpTraceAll(kmsAPI.KMSCreateKeyHandler))).Queries("key-id", "{key-id:.*}")

    public JsonResponse<ApiResult> put$setting(final CreateBody body) {
        validateApi(body, messages -> {});
        validateAttributes(body.attributes, this::throwValidationErrorApi);
        body.crudMode = CrudMode.CREATE;
        final Group entity = getGroup(body).orElseGet(() -> {
            throwValidationErrorApi(messages -> {
                messages.addErrorsCrudFailedToCreateInstance(GLOBAL);
            });
            return null;

            throwValidationErrorApi(messages -> messages.addErrorsCrudFailedToCreateCrudTable(GLOBAL, "doc is required"));
        }
        validateFields(body.doc, this::throwValidationErrorApi);
        body.crudMode = CrudMode.CREATE;
        final Map<String, Object> doc = getDoc(body).map(entity -> {
            try {
                entity.putAll(fessConfig.convertToStorableDoc(body.doc));

        return predGroupId.and(predArtifactId);
    }

    /**
     * In order to reuse the glob matcher from the filesystem, we need
     * to create Path instances.  Those are only used with the toString method.
     * This hack works because the only system-dependent thing is the path
     * separator which should not be part of the groupId or artifactId.
     */

    int expectedHashCode = 0;
    for (E element : elements) {
      expectedHashCode += ((element == null) ? 0 : element.hashCode());
    }

    elements.add(null);
    collection = getSubjectGenerator().create(elements.toArray());
    assertEquals(
        "A Set's hashCode() should be the sum of those of its elements (with "
            + "a null element counting as having a hash of zero).",
        expectedHashCode,