if (value instanceof File) {
            File file = (File) value;
            if (file.getPath().equals(getValue())) {
                return this;
            }
        }
        return snapshotter.snapshot(value);
    }

    @Override
    public void appendToHasher(Hasher hasher) {
        hasher.putString(getValue());
    }

            InstrumentationAnalysisTransform.class,
            spec -> {
                spec.getFrom().attribute(INSTRUMENTED_ATTRIBUTE, NOT_INSTRUMENTED.getValue());
                spec.getTo().attribute(INSTRUMENTED_ATTRIBUTE, ANALYZED_ARTIFACT.getValue());
                spec.parameters(params -> {
                    params.getBuildService().set(service);
                    params.getContextId().set(contextId);

                configConfigMap.put(key.substring(CONFIG_PREFIX.length()), entry.getValue());
            } else if (key.startsWith(CLIENT_PREFIX)) {
                clientConfigMap.put(key.substring(CLIENT_PREFIX.length()), entry.getValue());
            } else if (key.startsWith(XPATH_PREFIX)) {
                xpathConfigMap.put(key.substring(XPATH_PREFIX.length()), entry.getValue());
            } else if (key.startsWith(META_PREFIX)) {

    if (ceilingEntry != null
        && ceilingEntry.getValue().isConnected(range)
        && !ceilingEntry.getValue().intersection(range).isEmpty()) {
      return true;
    }
    Entry<Cut<C>, Range<C>> priorEntry = rangesByLowerBound.lowerEntry(range.lowerBound);
    return priorEntry != null
        && priorEntry.getValue().isConnected(range)
        && !priorEntry.getValue().intersection(range).isEmpty();
  }

  @Override

        if (type.isInstance(getValue())) {
            return type.cast(this);
        }
        if (type.isEnum()) {
            return type.cast(Enum.valueOf(Cast.uncheckedNonnullCast(type.asSubclass(Enum.class)), getValue()));
        }
        if (Named.class.isAssignableFrom(type)) {
            return type.cast(instantiator.named(type.asSubclass(Named.class), getValue()));
        }

  }

  protected final V v0() {
    return e0().getValue();
  }

  protected final K k1() {
    return e1().getKey();
  }

  protected final V v1() {
    return e1().getValue();
  }

  protected final K k2() {
    return e2().getKey();
  }

  protected final V v2() {
    return e2().getValue();
  }

  protected final K k3() {
    return e3().getKey();

        assertEquals("local-profile-prop-value", pom.getValue("properties/local-profile-prop"));
    }

    /**
     * MNG-4107
     */
    @Test
    void testPomAndSettingsInterpolation() throws Exception {
        PomTestWrapper pom = buildPom("test-pom-and-settings-interpolation");
        assertEquals("applied", pom.getValue("properties/settingsProfile"));
        assertEquals("applied", pom.getValue("properties/pomProfile"));

    for (Entry<K, V> entry : expected) {
      assertEquals(
          "Wrong key for value " + entry.getValue(),
          entry.getKey(),
          getMap().inverse().get(entry.getValue()));
    }
  }

  @Override
  protected void expectMissing(Entry<K, V>... entries) {
    super.expectMissing(entries);
    for (Entry<K, V> entry : entries) {

      int columnIndex = requireNonNull(columnKeyToIndex.get(columnKey));
      V existingValue = values[rowIndex][columnIndex];
      checkNoDuplicate(rowKey, columnKey, existingValue, cell.getValue());
      values[rowIndex][columnIndex] = cell.getValue();
      rowCounts[rowIndex]++;
      columnCounts[columnIndex]++;
      cellRowIndices[i] = rowIndex;
      cellColumnIndices[i] = columnIndex;
    }

  if (replicate_attr.getValue().empty())
    return op.emitOpError()
           << "has an empty '" << kReplicationInfoAttr << "' attribute.";
  if (failed(IsValidDeviceTypeOrEmpty(compile_attr))) {
    return op.emitOpError() << "has invalid '" << kCompileDeviceTypeAttr
                            << "' value '" << compile_attr.getValue() << "'";
  }
  return success();
}