if (type.isAssignableFrom(untypedView.getType())) {
            @SuppressWarnings("unchecked") ModelView<T> view = (ModelView<T>) untypedView;
            return view;
        } else {
            // TODO better exception type
            throw new IllegalArgumentException("Model view of type " + untypedView.getType() + " requested as " + type);
        }
    }

        when:
        container.named("a", method)
        then:
        ex = thrown(Throwable)
        assertDoesNotAllowMethod(ex, methodUnderTest)

        when:
        container.named("a", getType(), method)
        then:
        ex = thrown(Throwable)
        assertDoesNotAllowMethod(ex, methodUnderTest)

        when:
        container.withType(container.type).named("a").configure(method)
        then:

    SmallVector<Value> newOperands;
    newOperands.reserve(op->getNumOperands());
    for (auto operand : op->getOperands()) {
      if (QuantizedType::getQuantizedElementType(operand.getType())) {
        auto newTy = QuantizedType::castToExpressedType(operand.getType());
        newOperands.push_back(
            rewriter.create<TFL::DequantizeOp>(loc, newTy, operand));
        continue;
      }

      newOperands.push_back(operand);
    }

    auto weight = op->getOperand(1);
    auto weight_type =
        mlir::dyn_cast_or_null<mlir::RankedTensorType>(weight.getType());
    if (weight_type == nullptr || !weight_type.hasStaticShape()) return false;

    auto output = op->getResult(0);
    auto output_type =
        mlir::dyn_cast_or_null<mlir::RankedTensorType>(output.getType());
    if (output_type == nullptr || !output_type.hasStaticShape()) return false;

    int64_t cols = 1;

            return DefaultFileChange.added(path, propertyTitle, current.getType(), current.getNormalizedPath());
        }

        @Override
        public Change removed(String path, String propertyTitle, FileSystemLocationFingerprint previous) {
            return DefaultFileChange.removed(path, propertyTitle, previous.getType(), previous.getNormalizedPath());
        }

        @Override

        assertEquals(getRequiredProperty(TestProperties.TEST_USER_DOMAIN_SHORT), s.getDomainName());
        assertEquals(getTestUser(), s.getAccountName());
        assertEquals(jcifs.SID.SID_TYPE_USER, s.getType());
    }


    @Test
    public void resolveGroupSID () throws IOException {
        String sid = getRequiredProperty(TestProperties.TEST_GROUP_SID);
        SID s = new SID(sid);

 */
public interface FilterableBytecodeInterceptor {

    BytecodeInterceptorType getType();

    /**
     * A marker interface that indicates that a class is used for bytecode upgrades.
     */
    interface BytecodeUpgradeInterceptor extends FilterableBytecodeInterceptor {
        @Override
        default BytecodeInterceptorType getType() {
            return BytecodeInterceptorType.BYTECODE_UPGRADE;
        }
    }

      auto current_type = quant::QuantizedType::getQuantizedElementType(
                              quantize_output.getType())
                              .getStorageType();
      if (current_type == input_type) {  // int8 == int8
        arg_type = quantize_output.getType();
        new_arg = block.addArgument(arg_type, loc);
        quantize_output.replaceAllUsesWith(new_arg);

      .def("getArguments",
           [](mlir::func::FuncOp& f) { return f.getArguments().vec(); })
      .def("getName", [](mlir::func::FuncOp& f) { return f.getName().str(); })
      .def("getType", &mlir::func::FuncOp::getFunctionType);

  py::class_<mlir::func::ReturnOp>(m, "ReturnOp")
      .def("create",
           [](mlir::OpBuilder& opb, mlir::Location loc,

        property.convention(consumer);
    }

    public abstract BuildServiceDetails<T, P> getServiceDetails();

    public abstract String getName();

    @Override
    @Nonnull
    public abstract Class<T> getType();

    /**
     * Returns the identifier for the build that owns this service.
     */