def test_conv_ptq_model(
      self,
      activation_fn: Optional[ops.Operation],
      has_bias: bool,
      has_batch_norm: bool,
      target_opset: quant_opts_pb2.OpSet,
      input_shape_dynamic: bool,
      enable_per_channel_quantization: bool,
      dilations: Sequence[int] = None,
  ):
    input_shape = [None, None, None, 3] if input_shape_dynamic else [1, 3, 4, 3]

	PackageFile   map[string]string // map package path to .a file with export data
	Standard      map[string]bool   // map package path to whether it's in the standard library
	PackageVetx   map[string]string // map package path to vetx data from earlier vet run
	VetxOnly      bool              // only compute vetx data; don't report detected problems
	VetxOutput    string            // write vetx data to this output file

                              mlir::ModuleOp module,
                              bool lift_varhandle_ops_to_args,
                              bool include_variables_in_initializers);
};

Status SavedModelSignatureDefImporter::LiftVariables(
    const SavedModelBundle& bundle, mlir::ModuleOp module,
    const bool lift_varhandle_ops_to_args,
    const bool include_variables_in_initializers) {

		existingNode    *v1.Node
		createError     error
		getError        error
		patchError      error
		deleteError     error
		expectedResult  bool
		expectedActions int
		testSavedNode   bool
		savedNodeIndex  int
		savedNodeCMAD   bool
	}{
		{
			name:            "success case - new node",
			newNode:         &v1.Node{},
			expectedResult:  true,
			expectedActions: 1,
		},

			Containers: []v1.Container{
				{Image: "foobar"},
			},
		},
	}

	testCases := map[string]struct {
		enableJobFailurePolicy        bool
		enableBackoffLimitPerIndex    bool
		enableJobSuccessPolicy        bool
		enableJobPodReplacementPolicy bool
		job                           batch.Job
		pods                          []v1.Pod
		wantStatus                    batch.JobStatus
	}{

// and perform translations from InTree PVs and Inline to CSI
type InTreeToCSITranslator interface {
	IsPVMigratable(pv *v1.PersistentVolume) bool
	IsInlineMigratable(vol *v1.Volume) bool
	IsMigratableIntreePluginByName(inTreePluginName string) bool
	GetInTreePluginNameFromSpec(pv *v1.PersistentVolume, vol *v1.Volume) (string, error)
	GetCSINameFromInTreeName(pluginName string) (string, error)

	err    error
}

type fakeExtender struct {
	isBinder          bool
	interestedPodName string
	ignorable         bool
	gotBind           bool
	errBind           bool
	isPrioritizer     bool
	isFilter          bool
}

func (f *fakeExtender) Name() string {
	return "fakeExtender"
}

func (f *fakeExtender) IsIgnorable() bool {
	return f.ignorable
}

func (f *fakeExtender) ProcessPreemption(

				SucceededCount:   ptr.To[int32](4),
			},
		},
	}

	cases := map[string]struct {
		enableJobPodFailurePolicy     bool
		enableJobBackoffLimitPerIndex bool
		enableJobPodReplacementPolicy bool
		enableJobManageBy             bool
		enableJobSuccessPolicy        bool
		job                           batch.Job
		wantJob                       batch.Job
	}{
		"generate selectors": {
			job: batch.Job{

func validateReplicationDestination(ctx context.Context, bucket string, rCfg *replication.Config, checkRemote bool) (bool, APIError) {
	var arns []string
	if rCfg.RoleArn != "" {
		arns = append(arns, rCfg.RoleArn)
	} else {
		for _, rule := range rCfg.Rules {
			arns = append(arns, rule.Destination.String())
		}
	}
	var sameTarget bool
	for _, arnStr := range arns {
		arn, err := madmin.ParseARN(arnStr)
		if err != nil {

	return fileDescriptor_662262cc70094b41, []int{0}
}
func (m *CSIDriver) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CSIDriver) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *CSIDriver) XXX_Merge(src proto.Message) {