func TestPolicyRestrictedCanAdmitPodResult(t *testing.T) {
	tcases := []struct {
		name     string
		hint     TopologyHint
		expected bool
	}{
		{
			name:     "Preferred is set to false in topology hints",
			hint:     TopologyHint{nil, false},
			expected: false,
		},
		{
			name:     "Preferred is set to true in topology hints",
			hint:     TopologyHint{nil, true},
			expected: true,
		},
	}

	for _, tc := range tcases {

        [
            new SimplePropertyAnnotationHandler(TestNested, INPUT, [ItDepends]),
            new SimplePropertyAnnotationHandler(Long, INPUT, [ItDepends, Tint]),
            new SimplePropertyAnnotationHandler(Short, INPUT, [Tint]),
        ],
        [ItDepends, Tint],
        typeAnnotationMetadataStore,
        { annotations -> annotations.get(TYPE)?.annotationType() },
        TestCrossBuildInMemoryCacheFactory.instance(),

        V31,
        V40
    }

    /**
     * Gets the hint about the source of the problem. While the syntax of this hint is unspecified and depends on the
     * creator of the problem, the general expectation is that the hint provides sufficient information to the user to
     * track the problem back to its origin. A concrete example for such a source hint can be the file path or URL from
     * which a POM was read.
     *

// Package byteorder provides functions for decoding and encoding
// little and big endian integer types from/to byte slices.
package byteorder

func LeUint16(b []byte) uint16 {
	_ = b[1] // bounds check hint to compiler; see golang.org/issue/14808
	return uint16(b[0]) | uint16(b[1])<<8
}

func LePutUint16(b []byte, v uint16) {
	_ = b[1] // early bounds check to guarantee safety of writes below
	b[0] = byte(v)

}

def ConvertTFQuantTypes : Pass<"convert-tf-quant-types", "mlir::func::FuncOp"> {
  let summary = "Replace TensorFlow qint types with int types.";

  let description = [{
    Converts TF ops with qint types to int types. Some UniformQuantized ops
    argument/result allow qint type only. For such cases, add qint <-> int
    tf.Cast around the ops so that they are still valid.
  }];

name: reviewdog
on: [pull_request]
jobs:
  golangci-lint:
    name: runner / golangci-lint
    runs-on: ubuntu-latest
    steps:
      - name: Check out code into the Go module directory
        uses: actions/checkout@v4
      - name: golangci-lint
        uses: reviewdog/action-golangci-lint@v2

      - name: Setup reviewdog
        uses: reviewdog/action-setup@v1

      - name: gofumpt -s with reviewdog
        env:

		i = m
	}
	return i
}

func min3(b []*batchCursor, i0, i1, i2 int) int {
	minIdx := i0
	minT := maxTime
	if i0 < len(b) {
		minT = b[i0].ev.time
	}
	if i1 < len(b) {
		if t := b[i1].ev.time; t < minT {
			minT = t
			minIdx = i1
		}
	}
	if i2 < len(b) {
		if t := b[i2].ev.time; t < minT {
			minT = t
			minIdx = i2
		}
	}
	return minIdx

  pybind11_protobuf::ImportNativeProtoCasters();

  m.def(
      // If the function signature changes, likely its corresponding .pyi type
      // hinting should also change.
      // LINT.IfChange
      "quantize_qat_model",
      [](const absl::string_view src_saved_model_path,
         const absl::string_view dst_saved_model_path,
         const QuantizationOptions& quantization_options,

# ==============================================================================

# LINT.IfChange(savedmodel_to_stablehlo)
def savedmodel_to_stablehlo(
    input_path: str,
    exported_model_signatures: list[str] = ["serving_default"],
    tag_names: list[str] = ["serve"],
    input_arg_shapes_str: str = "",
) -> bytes: ...
# LINT.ThenChange()

# LINT.IfChange(tensorflow_module_to_stablehlo)
def tensorflow_module_to_stablehlo(

          std::vector<std::string>{"serving_default"},
      py::arg("tag_names") = std::vector<std::string>{"serve"},
      py::arg("input_arg_shapes_str") = "");
  // LINT.ThenChange(pywrap_tensorflow_to_stablehlo.pyi:savedmodel_to_stablehlo)
  //
  // LINT.IfChange(tensorflow_module_to_stablehlo)
  m.def(
      "tensorflow_module_to_stablehlo",
      [](absl::string_view module_op_str,