class GraphDecomposeTest(test.TestCase):

  def testAddN(self):
    add = def_function.function(gen_composite_ops.my_add_n)
    t1 = constant_op.constant([[1.0, 2.0], [3.0, 4.0]])
    t2 = constant_op.constant([[1.0, 2.0], [3.0, 4.0]])
    t3 = constant_op.constant([[1.0, 2.0], [3.0, 4.0]])
    sq1 = add([t1])
    sq2 = add([t1, t2])
    sq3 = add([t1, t2, t3])
    self.assertAllEqual(sq1.numpy().reshape(-1), [1, 2, 3, 4])

  return %0 : tensor<16x4xf32>
}
// Check that the constant is cloned with same value.
// The duplicated constant is the last index of the ConcatV2 op (which
// accepts a variadic arg).
// CHECK-DAG: %[[CST_0:.*]] = "tf.Const"()
// CHECK-SAME: value = dense<1> : tensor<i32>
// CHECK-DAG: %[[CST_1:.*]] = "tf.Const"()
// CHECK-SAME: value = dense<1> : tensor<i32>

// Check that the constants used for tf.ConcatV2 and tf.AddV2 are different.

	// binary exponent, so these constants cannot be represented anymore
	// internally. However, the language spec does not preclude other
	// implementations from handling these. Don't check the error.
	// var _ = 1e2147483647 // "constant too large"
	// var _ = 1e646456993  // "constant too large"

	// Any implementation must be able to handle these constants at

// only be used as the shape-determining operand; it will not replace other
// usages of the original constant. If the operands are not constants (i.e.
// results of some other computation), then the pass recursively traverses the
// call tree upwards and duplicates all constants found in the subtree in a
// similar manner.
//
// This pass may be used to avoid placing shape-determining constants in the CPU

// function signature. Constants are also transposed accordingly.

// CHECK-LABEL: nchw_conv_with_bias_add
// CHECK-SAME: %[[ARG:.+]]: tensor<1x2x5x5xf32>
func.func @nchw_conv_with_bias_add(%arg0: tensor<1x2x5x5xf32>) -> tensor<1x4x5x5xf32> {
  %0 = stablehlo.constant dense<2.000000e+00> : tensor<4x2x3x3xf32>
  %1 = stablehlo.constant dense<3.000000e+00> : tensor<1x4x5x5xf32>

      Class<T> enumClass) {
    synchronized (enumConstantCache) {
      Map<String, WeakReference<? extends Enum<?>>> constants = enumConstantCache.get(enumClass);
      if (constants == null) {
        constants = populateCache(enumClass);
      }
      return constants;
    }
  }

  /**
   * Returns a serializable converter that converts between strings and {@code enum} values of type

// CHECK:  return %1
}

// CHECK-LABEL: fakeQuantFolded
func.func @fakeQuantFolded() -> (tensor<8xf32>) {
  %in = arith.constant dense<0.0> : tensor<8xf32>
  %min = arith.constant dense<0.0> : tensor<f32>
  %max = arith.constant dense<255.0> : tensor<f32>
  %mini = "tf.Identity"(%min) : (tensor<f32>) -> tensor<f32>
  %maxi = "tf.Identity"(%max) : (tensor<f32>) -> tensor<f32>

//
// It should be guaranteed that `rhs_op` is either:
// 1. `stablehlo.constant`
// 2. `stablehlo.constant`->`stablehlo.transpose`.
//
// TODO: b/328156969 - Support the case where the RHS doesn't come from a
// constant.
TFL::QConstOp CreateTflConstOpForFilter(Operation* rhs_op,
                                        PatternRewriter& rewriter,

      Class<T> enumClass) {
    synchronized (enumConstantCache) {
      Map<String, WeakReference<? extends Enum<?>>> constants = enumConstantCache.get(enumClass);
      if (constants == null) {
        constants = populateCache(enumClass);
      }
      return constants;
    }
  }

  /**
   * Returns a serializable converter that converts between strings and {@code enum} values of type

PACKAGE blank

IMPORTPATH
	testdata/blank

IMPORTS
	os

FILENAMES
	testdata/blank.go

CONSTANTS
	// T constants counting from unexported constants. 
	const (
		tweedledee	T	= iota
		tweedledum
		C1
		C2
		alice
		C3
		redQueen	int	= iota
		C4
	)

	// Constants with a single type that is not propagated. 
	const (
		zero		os.FileMode	= 0
		Default				= 0644
		Useless				= 0312