enum class ScaleConstraintType {
  OutputInputSameScale,
  OutputInputFreeScale,
  CustomScale,
};

// Each kernel signature has its own specification for scales.
struct KernelSpec {
  // Scale constraint
  ScaleConstraintType type;

  // Custom function to derive the scales. Only available when the scale
  // constraint is `CustomScale`.
  ScaleFn scale_fn;
};

class KernelSpecs {
 public:

    public Lifecycle(String id, List<String> phases, Map<String, LifecyclePhase> defaultPhases) {
        this.id = id;
        this.phases = phases;
        this.defaultPhases = defaultPhases;
    }

    public Lifecycle(org.apache.maven.api.Lifecycle lifecycle) {
        this.lifecycle = lifecycle;
        this.id = lifecycle.id();
        this.phases = lifecycle.phases().stream()

// RUN: tf-opt %s -tf-shape-inference=input-arg-shapes=1 -verify-diagnostics -split-input-file | FileCheck %s
// RUN: not tf-opt %s -tf-shape-inference=input-arg-shapes=* 2>&1 | FileCheck --check-prefix=INPUT_ARG_SHAPES_ERROR %s
// INPUT_ARG_SHAPES_ERROR: Missing input argument shapes

module attributes {tf.versions = {bad_consumers = [], min_consumer = 0 : i32, producer = 268 : i32}} {
    // CHECK-LABEL: func.func @main

                    Map<String, LifecyclePhase> phases = getLifecyclePhases(lifecycleId);
                    if (phases != null) {
                        Lifecycle lifecycle = new Lifecycle();

                        lifecycle.setId(lifecycleId);
                        lifecycle.setLifecyclePhases(phases);

                        lifecycleMap.put(lifecycleId, lifecycle);
                    }

        private final String name;
        private final List<Plugin> plugins;
        private final List<Lifecycle.Phase> phases;

        DefaultPhase(String name, List<Plugin> plugins, List<Lifecycle.Phase> phases) {
            this.name = name;
            this.plugins = plugins;
            this.phases = phases;
        }

        @Override
        public String name() {
            return name;
        }

        cleanup:
        workerLeaseService?.stop()
    }

    def "BuildOperationExecutor can fully utilize worker leases when multiple threads owning worker leases are submitting work (maxWorkers: #maxWorkers)"() {
        CountDownLatch leaseAcquiredLatch = new CountDownLatch(maxWorkers)
        CountDownLatch runningLatch = new CountDownLatch(maxWorkers)

    func.func @main(%arg0 : tensor<?xf32>) -> tensor<?xf32> {
      %scales = "tf.Const"() { value = dense<1.0> : tensor<f32> } : () -> tensor<f32>
      %zps = "tf.Const"() { value = dense<3> : tensor<i32> } : () -> tensor<i32>

      %0 = "tf.UniformQuantize"(%arg0, %scales, %zps) {
        quantization_axis = -1 : i64, quantization_min_val = -128 : i64, quantization_max_val = 127 : i64

					}
				}
			}

			leases, err := fakeReconciler.ListLeases()
			if err != nil {
				t.Errorf("unexpected error: %v", err)
			}
			// sort for comparison
			sort.Strings(leases)
			sort.Strings(test.expectLeases)
			if !reflect.DeepEqual(leases, test.expectLeases) {
				t.Errorf("expected %v got: %v", test.expectLeases, leases)
			}

			for _, server := range test.servers {

     *
     * @return the unique identifier for this lifecycle
     */
    @Override
    String id();

    /**
     * Collection of phases for this lifecycle
     */
    Collection<Phase> phases();

    /**
     * Pre-ordered list of phases.
     * If not provided, a default order will be computed.
     */
    default Optional<List<String>> orderedPhases() {
        return Optional.empty();
    }

        this.id = id;
    } // -- void setId( String )

    /**
     * Set the phase mappings for this lifecycle.
     *
     * @param phases a phases object.
     */
    public void setPhases(java.util.List<Phase> phases) {
        this.phases = phases;
    } // -- void setPhases( java.util.List )