result.setCreatedBy(DfTypeUtil.toString(source.get("createdBy")));
            result.setCreatedTime(DfTypeUtil.toLong(source.get("createdTime")));
            result.setMaxSize(DfTypeUtil.toInteger(source.get("maxSize")));
            result.setQuery(DfTypeUtil.toString(source.get("query")));
            result.setTerm(DfTypeUtil.toString(source.get("term")));

        for (Map<String, Object> elem : jobLogList) {
            deleteMethod("/api/admin/joblog/log/" + elem.get("id"));
        }

        final List<Map<String, Object>> crawlingInfoList = readCrawlingInfo(fileConfigId);
        for (Map<String, Object> elem : crawlingInfoList) {
            deleteMethod("/api/admin/crawlinginfo/log/" + elem.get("id"));
        }

            final Object elevateWord = sourceArray[i].get(FieldNames.ARRAY_VALUE);
            final Object boost = sourceArray[i].get(ELEVATE_WORD_BOOST);
            @SuppressWarnings("unchecked")
            final List<String> readings = (List<String>) sourceArray[i].get(ELEVATE_WORD_READING);
            @SuppressWarnings("unchecked")
            final List<String> fields = (List<String>) sourceArray[i].get(ELEVATE_WORD_FIELDS);

        assertEquals(AvPair.MsvAvFlags, pairs.get(0).getType(), "First pair should be MsvAvFlags");
        assertTrue(pairs.get(0) instanceof AvFlags, "First pair should be AvFlags instance");

        // Check second pair (AvTimestamp)
        assertEquals(AvPair.MsvAvTimestamp, pairs.get(1).getType(), "Second pair should be MsvAvTimestamp");

      Striped<Lock> get(int stripes) {
        return new Striped.SmallLazyStriped<>(stripes, LOCK_SUPPLIER);
      }
    },
    LAZY_LARGE {
      @Override
      Striped<Lock> get(int stripes) {
        return new Striped.LargeLazyStriped<>(stripes, LOCK_SUPPLIER);
      }
    };

    abstract Striped<Lock> get(int stripes);
  }

  private Striped<Lock> striped;
  private int[] stripes;

    }

    /**
     * Get the end of file position
     *
     * @return the endOfFile
     */
    public final long getEndOfFile() {
        return this.endOfFile;
    }

    /**
     * Get the file ID
     *
     * @return the fileId
     */
    public byte[] getFileId() {
        return this.fileId;
    }

    /**
     * Get the file name
     *

    return ArrayListMultimap.create();
  }

  /** Confirm that get() returns a List implementing RandomAccess. */
  public void testGetRandomAccess() {
    Multimap<String, Integer> multimap = create();
    multimap.put("foo", 1);
    multimap.put("foo", 3);
    assertTrue(multimap.get("foo") instanceof RandomAccess);
    assertTrue(multimap.get("bar") instanceof RandomAccess);
  }

            if (parameters.getPull().get()) {
                parameters.getBaseImages().get().forEach(this::pullBaseImage);
            }

            LoggedExec.exec(execOperations, spec -> {
                spec.executable("docker");

                spec.args("build", parameters.getDockerContext().get().getAsFile().getAbsolutePath());

                if (parameters.getNoCache().get()) {

        this.maxReceiveSize = RdmaCapabilities.DEFAULT_MAX_RECEIVE_SIZE;
        this.maxFragmentedSize = RdmaCapabilities.DEFAULT_MAX_FRAGMENTED_SIZE;
    }

    /**
     * Get minimum protocol version
     *
     * @return minimum version
     */
    public int getMinVersion() {
        return minVersion;
    }

    /**
     * Set minimum protocol version
     *

  public void testNewReference() throws Exception {
    assertThat(Atomics.newReference().get()).isNull();
  }

  public void testNewReference_withInitialValue() throws Exception {
    assertThat(Atomics.newReference(null).get()).isNull();
    assertEquals(OBJECT, Atomics.newReference(OBJECT).get());
  }

  public void testNewReferenceArray_withLength() throws Exception {
    int length = 42;