fun sleep(durationNanos: Long) {
    taskRunner.withLock {
      val sleepUntil = nanoTime + durationNanos
      yieldUntil { nanoTime >= sleepUntil }
    }
  }

  /**
   * Artificially stall until manually resumed by the test thread with [runTasks]. Use this to
   * simulate races in tasks that doesn't have a deterministic sequence.
   */
  fun yield() {
    taskRunner.assertLockNotHeld()

            final Map<String, Object> contextMap = new HashMap<>();
            contextMap.put("doc", dataMap);
            final Map<String, Object> paramMap = new HashMap<>(dataMap.size() + 2);
            paramMap.putAll(dataMap);
            paramMap.put("value", target);
            paramMap.put("context", contextMap);
            target = evaluateValue(scriptType, template, paramMap);
        }

     * @return this exception for chaining
     */
    public SmbOperationException withContext(Map<String, Object> contextMap) {
        if (contextMap != null) {
            this.context.putAll(contextMap);
        }
        return this;
    }

    // Getters
    public ErrorCode getErrorCode() {
        return errorCode;
    }

    public ErrorCategory getErrorCategory() {

  /**
   * Builds a thread-safe map. This method does not alter the state of this {@code MapMaker}
   * instance, so it can be invoked again to create multiple independent maps.
   *
   * <p>The bulk operations {@code putAll}, {@code equals}, and {@code clear} are not guaranteed to
   * be performed atomically on the returned map. Additionally, {@code size} and {@code

                    if (source != null) {
                        docMap.putAll(source);
                    }
                    final Map<String, DocumentField> fields = hit.getFields();
                    if (fields != null) {
                        docMap.putAll(fields.entrySet()
                                .stream()

            if (l != null) {
                l.clearValue();
            }
        }
        return old;
    }

    void putAllSubstituted(Map<? extends String, ? extends String> m) {
        storage.putAll(m);
    }

    public String put(String key, List<String> commentLines, List<String> valueLines) {
        commentLines = new ArrayList<>(commentLines);
        valueLines = new ArrayList<>(valueLines);

            if (l != null) {
                l.clearValue();
            }
        }
        return old;
    }

    void putAllSubstituted(Map<? extends String, ? extends String> m) {
        storage.putAll(m);
    }

    public String put(String key, List<String> commentLines, List<String> valueLines) {
        commentLines = new ArrayList<>(commentLines);
        valueLines = new ArrayList<>(valueLines);

     *
     * @throws NullPointerException if any key or value in {@code map} is null
     */
    @CanIgnoreReturnValue
    @Override
    public Builder<K, V> putAll(Map<? extends K, ? extends V> map) {
      super.putAll(map);
      return this;
    }

    /**
     * Adds all the given entries to the built map. Duplicate keys, according to the comparator

  /**
   * Builds a thread-safe map. This method does not alter the state of this {@code MapMaker}
   * instance, so it can be invoked again to create multiple independent maps.
   *
   * <p>The bulk operations {@code putAll}, {@code equals}, and {@code clear} are not guaranteed to
   * be performed atomically on the returned map. Additionally, {@code size} and {@code

        try (FileOutputStream out = new FileOutputStream(propFile)) {
            final Properties prop = new Properties();
            prop.putAll(ComponentUtil.getSystemProperties());
            final LaJobRuntime jobRuntime = ComponentUtil.getJobHelper().getJobRuntime();
            if (jobRuntime != null) {