def "constructors with fewer parameters are first"() {
        def lhs = Stub(ClassGenerator.GeneratedConstructor)
        lhs.parameterTypes >> [String]
        def rhs = Stub(ClassGenerator.GeneratedConstructor)
        rhs.parameterTypes >> [String, Number]

        expect:
        comparator.compare(lhs, rhs) == -1
        comparator.compare(rhs, lhs) == 1
    }

// RUN: stablehlo-quant-opt -optimize-int-graph -split-input-file %s -verify-diagnostics | FileCheck %s

// CHECK-LABEL: func @convolution_add_add
func.func @convolution_add_add(
    %lhs: tensor<?x3x2x1xi8>, %rhs: tensor<2x1x1x1xi8>,
    %zp_offset: tensor<?x2x2x1xi32>, %bias: tensor<1xi32>
  ) -> tensor<?x2x2x1xi32> {
  // CHECK-DAG: %[[conv:.*]] = mhlo.convolution
  // CHECK-DAG: %[[combined:.*]] = chlo.broadcast_add %[[zp_offset:.*]], %[[bias:.*]]

		case token.ASSIGN, token.DEFINE:
			if len(s.Lhs) == 0 {
				check.error(s, InvalidSyntaxTree, "missing lhs in assignment")
				return
			}
			if s.Tok == token.DEFINE {
				check.shortVarDecl(inNode(s, s.TokPos), s.Lhs, s.Rhs)
			} else {
				// regular assignment
				check.assignVars(s.Lhs, s.Rhs)
			}

		default:
			// assignment operations
			if len(s.Lhs) != 1 || len(s.Rhs) != 1 {

func TestCertKeyContentEquals(t *testing.T) {
	tests := []struct {
		name     string
		lhs      *certKeyContent
		rhs      *certKeyContent
		expected bool
	}{
		{
			name:     "both nil",
			expected: true,
		},
		{
			name:     "lhs nil",
			rhs:      &certKeyContent{},
			expected: false,
		},
		{
			name:     "rhs nil",
			lhs:      &certKeyContent{},
			expected: false,
		},
		{
			name:     "same",

		SchemaProps: spec.SchemaProps{Type: []string{"object"}},
	}
)

func TestEquality(t *testing.T) {
	cases := []struct {
		name  string
		lhs   ref.Val
		rhs   ref.Val
		equal bool
	}{
		{
			name: "map lists are equal regardless of order",
			lhs: UnstructuredToVal([]interface{}{
				map[string]interface{}{
					"key": "a",
					"val": 1,
				},
				map[string]interface{}{
					"key": "b",

    (BinaryOp (TFL_ReshapeOp:$lhs $input, (Arith_ConstantOp:$shape $s)),
              $rhs, $act_fn),
    (BinaryOp $input, $rhs, $act_fn),
    [(AnyStaticShapeTensor $input),
     (AnyStaticShapeTensor $rhs),
     (IsRankLessThanEqualTo $input, $lhs),
     (IsRankLessThanEqualTo $lhs, $rhs),
     (IsReducedTailOfShape $lhs, $input),
     (HasOneUseOrUsedByOnlyBinaryOps $lhs),

        op, "unary einsum equation does not require transpose");
  } else if (needs_reduce_sum && !needs_transpose) {
    rewriter.replaceOp(op, lhs);
    return success();
  }

  lhs = createTransposeOp(lhs, lhs.getLoc(), lhs_transpose, &rewriter);
  rewriter.replaceOp(op, lhs);
  return success();
}

std::vector<int64_t> inverseTransposeVector(
    llvm::ArrayRef<int64_t> input, llvm::ArrayRef<int32_t> permutation) {

	// Expect T1 + T2 = T3 + T4

	var accP1xP1 projP1xP1
	lhs := NewIdentityPoint()
	rhs := NewIdentityPoint()

	accP1xP1.Add(lhs, &tmp1)
	lhs.fromP1xP1(&accP1xP1)
	accP1xP1.Add(lhs, &tmp2)
	lhs.fromP1xP1(&accP1xP1)

	accP1xP1.Add(rhs, &tmp3)
	rhs.fromP1xP1(&accP1xP1)
	accP1xP1.Add(rhs, &tmp4)
	rhs.fromP1xP1(&accP1xP1)

	if lhs.Equal(rhs) != 1 {
		t.Errorf("Consistency check on nafLookupTable5 failed")
	}

	// so that the conversion below happens).

	checkLHS := func(i int, typ *types.Type) {
		if n := lhs[i]; typ != nil && ir.DeclaredBy(n, stmt) && n.Type() == nil {
			base.Assertf(typ.Kind() == types.TNIL, "unexpected untyped nil")
			n.SetType(defaultType(typ))
		}
		if lhs[i].Typecheck() == 0 {
			lhs[i] = AssignExpr(lhs[i])
		}
		checkassign(lhs[i])
	}

	assignType := func(i int, typ *types.Type) {
		checkLHS(i, typ)

     *
     * @throws java.lang.Exception if any.
     */
    @Test
    void testCombineId() throws Exception {
        String lhs = "<props>" + "<property combine.id='LHS-ONLY'><name>LHS-ONLY</name><value>LHS</value></property>"
                + "<property combine.id='TOOVERWRITE'><name>TOOVERWRITE</name><value>LHS</value></property>"
                + "</props>";