},
		},
	}

	if !cmp.Equal(actual, expect, protocmp.Transform()) {
		t.Errorf("want %s, got %s", expect.String(), actual.String())
	}
}

func TestMetadataListMatcher(t *testing.T) {
	getWant := func(regex string) *matcher.MetadataMatcher {
		return &matcher.MetadataMatcher{
			Filter: "istio_authn",
			Path: []*matcher.MetadataMatcher_PathSegment{
				{
					Segment: &matcher.MetadataMatcher_PathSegment_Key{

  if (!image_type || !image_type.getElementType().isF32() ||
      image_type.getRank() != 4) {
    return func_.emitWarning() << "Image should be a 4D float tensor";
  }

  auto flow_type = mlir::dyn_cast_or_null<RankedTensorType>(
      func_.getFunctionType().getInput(1));
  if (!flow_type || !flow_type.getElementType().isF32() ||
      flow_type.getRank() != 4) {
    return func_.emitWarning() << "Flow should be a 4D float tensor";

  if (!(tensor_type && tensor_type.hasRank())) {
    return op->emitError()
           << "cannot convert op with unranked or non-tensor input type "
           << tensor_type << ".";
  }

  int rank = tensor_type.getRank();
  if (rank <= partition_dim) {
    return op->emitError() << "cannot partition " << first_operand_type
                           << " (rank = " << rank << ") along dimension "

def ZeroIntAttr
  : AttrConstraint<CPred<"$_self.cast<::mlir::IntegerAttr>().getInt() == 0">>;

// Checks if the value has rank at most 'n'.
class HasRankAtLeast<int n> : Constraint<
    CPred<"$0.getType().cast<ShapedType>().hasRank() && "
          "$0.getType().cast<ShapedType>().getRank() >= " # n>>;

// Checks value is not produced by a TFL_Quant or
// from TFL_Quant Op with same quant type.

  auto boxes_type =
      mlir::dyn_cast<RankedTensorType>(func_.getFunctionType().getInput(0));
  if (boxes_type == nullptr || !boxes_type.hasRank() ||
      boxes_type.getRank() != 2) {
    return func_.emitWarning() << "TFLite does not support batched input for "
                                  "non_max_suppression_padded";
  }
  return success();
}

                return endOfData();
            }
            return stack.getLast().next();
        }

        private void advanceIfNecessary() {
            while (!stack.isEmpty() && !hasNextWithCorrectDepth()) {
                if (stack.getLast().hasNext()) {
                    File next = stack.getLast().next();
                    stack.addLast(listFiles(next));
                } else {

        this.flags2 = Config.getInt(p, "jcifs.smb.client.flags2", 0);

        this.capabilities = Config.getInt(p, "jcifs.smb.client.capabilities", 0);

        this.sessionLimit = Config.getInt(p, "jcifs.smb.client.ssnLimit", SmbConstants.DEFAULT_SSN_LIMIT);

        this.maxRequestRetries = Config.getInt(p, "jcifs.smb.client.maxRequestRetries", 2);

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

  Builder b(op->getContext());
  *x = b.getI32IntegerAttr(mlir::cast<IntegerAttr>(elements[1]).getInt());
  *y = b.getI32IntegerAttr(mlir::cast<IntegerAttr>(elements[2]).getInt());
  *z = b.getI32IntegerAttr(mlir::cast<IntegerAttr>(elements[3]).getInt());

  return true;
}

                    value.removeIf(i -> i.getAlias().equals(importedClass.getAlias()));
                } catch (Exception e) {
                    throw UncheckedException.throwAsUncheckedException(e);
                }
            }
        }

        iter = source.getAST().getStaticImports().values().iterator();
        while (iter.hasNext()) {

  return type && type.getRank() == rank &&
         mlir::isa<FloatType>(type.getElementType());
}

// Returns true if the given `value` has the specified rank or has unranked
// type.
inline bool IsOfRankOrUnranked(Value value, int64_t rank) {
  RankedTensorType type = GetRankedTensorTypeForOperand(value);
  return !type || type.getRank() == rank;
}