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

        run 'jar'

        then:
        jar.manifest.mainAttributes.getValue('attr') == null

        when: "Attribute added"
        buildFile.text = jarWithManifest("attributes(attr: 'Hello')")
        run 'jar'

        then:
        executedAndNotSkipped ':jar'
        jar.manifest.mainAttributes.getValue('attr') == 'Hello'

        when: "Attribute modified"

      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;
    }

                } 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 (!mlir::isa<FlatSymbolRefAttr>(named_attr.getValue())) {
      return op->emitError() << "'tf_saved_model.bound_input' attribute should "
                                "be a FlatSymbolRefAttr";
    }
    auto symbol_name =
        mlir::cast<FlatSymbolRefAttr>(named_attr.getValue()).getValue();
    auto module = op->getParentOfType<ModuleOp>();

            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

        assertEquals(3, item.length);
        assertEquals("one", item[0].getValue());
        assertEquals("parent", item[0].getInputLocation());
        assertEquals("two", item[1].getValue());
        assertEquals("parent", item[1].getInputLocation());
        assertEquals("three", item[2].getValue());
        assertEquals("child", item[2].getInputLocation());
    }

    /**

  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;
}