@UsesNativeServices
abstract class AbstractFileMetadataAccessorTest extends Specification {
    @Rule
    TestNameTestDirectoryProvider tmpDir = new TestNameTestDirectoryProvider(getClass())
    abstract FileMetadataAccessor getAccessor()

    abstract void assertSameLastModified(FileMetadata fileMetadata, File file)

    void assertSameAccessType(FileMetadata fileMetadata, AccessType accessType) {
        assert fileMetadata.accessType == accessType

    OperationState state(op->getLoc(), op->getName());
    state.operands = dequantized_inputs;
    state.types = result_types;
    state.attributes = op->getAttrs();
    state.successors = op->getSuccessors();
    builder->setInsertionPoint(op);
    Operation* new_op = builder->create(state);

    // Insert quantize ops for every outputs and rewrite.
    for (int i = 0; i < op->getNumResults(); ++i) {

    // OperationState so we can add regions to the new op.
    OperationState state(op->getLoc(), op->getName().getStringRef(), operands,
                         new_results, op->getAttrs(), op->getSuccessors());
    for (Region& region : op->getRegions()) {
      Region& new_region = *state.addRegion();
      rewriter.inlineRegionBefore(region, new_region, new_region.begin());

        then:
        schema instanceof ManagedImplSchema
        def redundant = schema.properties[0]
        assert redundant instanceof ModelProperty
        redundant.getAccessor(PropertyAccessorType.IS_GETTER) != null
        redundant.getAccessor(PropertyAccessorType.GET_GETTER) != null
    }

    def "supports a boolean property with an is style getter"() {
        expect:

        }
    }

    private void writeSetMethod(ClassVisitor visitor, Type generatedType, ModelProperty<?> property) {
        WeaklyTypeReferencingMethod<?, ?> setter = property.getAccessor(SETTER);
        if (setter != null && property.getSchema() instanceof ScalarValueSchema) {
            // TODO - should we support this?

          "{0}.{1}", TF::TensorFlowDialect::getDialectNamespace(), op_name);
      OperationState state =
          OperationState(loc, tf_op_name, inner_op_operands, new_types, attrs,
                         op->getSuccessors(), new_regions);
      inner_op = rewriter.create(state);
    } else {
      bool disable_call_shape_inference = false;
      if (op->hasAttr("_disable_call_shape_inference")) {
        disable_call_shape_inference =

  OpBuilder builder(op);
  Operation *new_op = Operation::create(
      op->getLoc(), op->getName(), new_result_types, op->getOperands(),
      op->getAttrs(), op->getPropertiesStorage(), op->getSuccessors(),
      op->getNumRegions());
  builder.insert(new_op);

  // Move region bodies to the new operation.
  for (auto it : llvm::zip(op->getRegions(), new_op->getRegions())) {

  Operation* new_op = Operation::create(
      op_->getLoc(), op_->getName(), new_result_types, op_->getOperands(),
      op_->getAttrs(), op_->getPropertiesStorage(), op_->getSuccessors(),
      op_->getNumRegions());
  builder.insert(new_op);

  // Move regions to the new op.
  for (auto it : llvm::zip(op_->getRegions(), new_op->getRegions())) {
    Region& old_region = std::get<0>(it);