}

  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();

    }

    @Override
    public String getName() {
        return getValue().getName();
    }

    @Override
    public String getExtension() {
        return getValue().getExtension();
    }

    @Override
    public String getType() {
        return "";
    }

    @Override
    public String getClassifier() {
        return getValue().getClassifier();
    }

    @Override
    public File getFile() {

  }

  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();

      Entry<?, ?> that = (Entry<?, ?>) object;
      return Objects.equal(this.getKey(), that.getKey())
          && Objects.equal(this.getValue(), that.getValue());
    }
    return false;
  }

  /**
   * A sensible definition of {@link #hashCode()} in terms of {@link #getKey()} and {@link
   * #getValue()}. If you override either of these methods, you may wish to override {@link
   * #hashCode()} to forward to this implementation.
   *

    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) {

                } else if (property.getValue() instanceof File) {
                    propertyValue = ((File) property.getValue()).getAbsolutePath();
                } else if (property.getValue() instanceof URI) {
                    propertyValue = ((URI) property.getValue()).toASCIIString();
                } else {
                    propertyValue = property.getValue();
                }

            if (result.isFound()) {
                return result.getValue();
            }

            if (!isAlreadyConfiguring) {
                // Try to configure element
                result = _configure(name, params);
                if (result.isFound()) {
                    return result.getValue();
                }
            }

            // try the owner

  const auto &elements = mlir::cast<ArrayAttr>(attr).getValue();
  if (elements.size() != 4 ||
      std::any_of(elements.begin(), elements.end(),
                  [](Attribute e) { return !mlir::isa<IntegerAttr>(e); }))
    return false;

  if (mlir::cast<IntegerAttr>(elements.front()).getValue() != 1 ||
      mlir::cast<IntegerAttr>(elements.back()).getValue() != 1)
    return false;
  return true;
}

  if (!state) {
    return nullptr;
  }
  auto ops = state->getValue().ops;
  if (ops.size() != 1) {
    return nullptr;
  }
  Operation* source = *ops.begin();
  return source;
}

Attribute GetInitialValue(Operation* source) {
  if (auto global = dyn_cast<tf_saved_model::GlobalTensorOp>(source)) {
    if (global.getValue()) {
      return *global.getValue();
    }
  }
  return nullptr;
}

        final File fileTwo = new File("fileTwo")

        pathOption.getValue().add(fileOne)
        pathOption.getValue().add(fileTwo)

        when:
        pathOption.write(writerContextMock)

        then:
        1 * writerContextMock.writePathOption(optionName, pathOption.getValue(), joinBy)
    }