request.setSystemProperties(sysProperties);

        ModelBuildingResult result = builder.build(request);
        assertNotNull(result);
        assertNotNull(result.getEffectiveModel());
        assertEquals("activated-1", result.getEffectiveModel().getProperties().get("profile.file"));
        assertNull(result.getEffectiveModel().getProperties().get("profile.miss"));
    }

func (JSONSerializer) Value(ctx context.Context, field *Field, dst reflect.Value, fieldValue interface{}) (interface{}, error) {
	result, err := json.Marshal(fieldValue)
	if string(result) == "null" {
		if field.TagSettings["NOT NULL"] != "" {
			return "", nil
		}
		return nil, err
	}
	return string(result), err
}

// UnixSecondSerializer json serializer
type UnixSecondSerializer struct{}

      val headers = request.headers
      val result = ArrayList<Header>(headers.size + 4)
      result.add(Header(TARGET_METHOD, request.method))
      result.add(Header(TARGET_PATH, RequestLine.requestPath(request.url)))
      val host = request.header("Host")
      if (host != null) {
        result.add(Header(TARGET_AUTHORITY, host)) // Optional.
      }
      result.add(Header(TARGET_SCHEME, request.url.scheme))

                result.append(">")
            }

            @Override
            void onEndHtmlElement(String name) {
                result.append("</$name>")
            }

            @Override
            void onText(String text) {
                result.append(text)
            }
        })
        return result.toString()
    }

            Model model, List<Profile> profiles, ModelBuildingRequest request, ModelProblemCollector problems) {
        Model result = CACHE.computeIfAbsent(model, k -> new ConcurrentHashMap<>())
                .computeIfAbsent(profiles, l -> doInjectProfiles(model, profiles));
        return result == KEY ? model : result;
    }

    private Model doInjectProfiles(Model model, List<Profile> profiles) {
        Model orgModel = model;

      length += array.length;
    }
    int[] result = new int[checkNoOverflow(length)];
    int pos = 0;
    for (int[] array : arrays) {
      System.arraycopy(array, 0, result, pos, array.length);
      pos += array.length;
    }
    return result;
  }

  private static int checkNoOverflow(long result) {
    checkArgument(
        result == (int) result,

                    updateItems.add(item);
                }
                final SuggestWriterResult result =
                        suggestWriter.write(client, settings, index, updateItems.toArray(new SuggestItem[updateItems.size()]), false);
                if (result.hasFailure()) {
                    throw new SuggestIndexException(result.getFailures().get(0));
                }

/**
 * Instances of this class are responsible for determining whether it makes sense to "resume" a build (i.e., using
 * the {@code --resume} flag.
 */
public interface BuildResumptionAnalyzer {
    /**
     * Construct an instance of {@link BuildResumptionData} based on the outcome of the current Maven build.
     * @param result Outcome of the current Maven build.

                interpolator.addPostProcessor(postProcessor);
            }

            try {
                try {
                    result = interpolator.interpolate(result, recursionInterceptor);
                } catch (InterpolationException e) {
                    throw new ModelInterpolationException(e.getMessage(), e);
                }

                if (debug) {

    }

    public void merge(File existing, File result) throws RepositoryException {
        merge(existing != null ? existing.toPath() : null, result != null ? result.toPath() : null);
    }

    @Override
    public void merge(Path existing, Path result) throws RepositoryException {
        Metadata recessive = read(existing);

        merge(recessive);

        write(result, metadata);

        merged = true;
    }