%0 = stablehlo.constant dense<3.000000e+00> : tensor<1x1x1xf32>  // Input inverse scale.
    %1 = stablehlo.constant dense<1> : tensor<1x1x1xi8>  // Input zero point.
    %2 = stablehlo.constant dense<5> : tensor<2x3xi8>  // Quantized filter.
    %3 = stablehlo.constant dense<4> : tensor<1x1x3xi32>  // Precalculated q2 * z1.
    %4 = stablehlo.constant dense<3.000000e+03> : tensor<1x1x3xf32>  // Merged scale: s1 * s2.

        with(fixture.all(LoadBuildBuildOperationType)) {
            size() == 3
            it.find { it.details.buildPath == ":" }
            it.find { it.details.buildPath == ":include" }
            it.find { it.details.buildPath == ":include:inner-include" }
        }
        with(fixture.all(LoadProjectsBuildOperationType)) {
            size() == 3
            it.find { it.details.buildPath == ":" }

		{"s", StringValue("s")},
		{true, BoolValue(true)},
		{testTime, TimeValue(testTime)},
		{time.Hour, DurationValue(time.Hour)},
		{[]Attr{Int("i", 3)}, GroupValue(Int("i", 3))},
		{IntValue(4), IntValue(4)},
		{uint(2), Uint64Value(2)},
		{uint8(3), Uint64Value(3)},
		{uint16(4), Uint64Value(4)},
		{uint32(5), Uint64Value(5)},
		{uint64(6), Uint64Value(6)},
		{uintptr(7), Uint64Value(7)},
		{int8(8), Int64Value(8)},

	}

	if count := tx.Model(&item).Association("Contents").Count(); count != 3 {
		t.Errorf("expected %d contents, got %d", 3, count)
	}

	var contents []ItemContent
	if err := tx.Find(&contents).Error; err != nil {
		t.Errorf("failed to find contents, got error: %v", err)
	}
	if len(contents) != 3 {
		t.Errorf("expected %d contents, got %d", 3, len(contents))
	}

	// test delete

func.func @main(%input0: tensor<i32>, %input1: tensor<i32>) -> tensor<i32> {
  // CHECK: [[promises:%.*]]:3, [[futures:%.*]]:3 = "tf_mlrt.allocate_futures"
  // CHECK-SAME: num_futures = 3
  %promise_b, %promise_c, %promise_d, %future_b, %future_c, %future_d =
    "tf_mlrt.allocate_futures"()
    {num_futures = 3 : i32, resultSegmentSizes = array<i32: 3, 3>} : () ->
    (!mlrt.promise, !mlrt.promise, !mlrt.promise,

            logger3.log(it, "Test");
        }
        redirector.stop()

        then:
        3 * stdErrListener.onOutput("${Level.SEVERE.getLocalizedName()}: Test$EOL")
        3 * stdErrListener.onOutput("${Level.WARNING.getLocalizedName()}: Test$EOL")
        3 * stdErrListener.onOutput("${Level.INFO.getLocalizedName()}: Test$EOL")

iptables -t nat -A ISTIO_OUTPUT -o lo -s 127.0.0.6/32 -j RETURN
iptables -t nat -A ISTIO_OUTPUT -o lo ! -d 127.0.0.1/32 -p tcp -m multiport ! --dports 53,15008 -m owner --uid-owner 3 -j ISTIO_IN_REDIRECT
iptables -t nat -A ISTIO_OUTPUT -m owner --uid-owner 3 -j RETURN
iptables -t nat -A ISTIO_OUTPUT -o lo ! -d 127.0.0.1/32 -p tcp -m multiport ! --dports 53,15008 -m owner --uid-owner 4 -j ISTIO_IN_REDIRECT

		*GetUser("slice-hasone-3", Config{Account: true}),
	}

	DB.Create(&users)

	// Count
	AssertAssociationCount(t, users, "Account", 2, "")

	// Find
	var accounts []Account
	if DB.Model(&users).Association("Account").Find(&accounts); len(accounts) != 2 {
		t.Errorf("accounts count should be %v, but got %v", 3, len(accounts))
	}

	// Append

		case 'J': // January, Jan
			if len(layout) >= i+3 && layout[i:i+3] == "Jan" {
				if len(layout) >= i+7 && layout[i:i+7] == "January" {
					return layout[0:i], stdLongMonth, layout[i+7:]
				}
				if !startsWithLowerCase(layout[i+3:]) {
					return layout[0:i], stdMonth, layout[i+3:]
				}
			}

		case 'M': // Monday, Mon, MST
			if len(layout) >= i+3 {
				if layout[i:i+3] == "Mon" {

        dependency.accessRules[1].pattern == 'id-nonaccessible'
        dependency.accessRules[2].kind == 2
        dependency.accessRules[2].pattern == 'id-discouraged'
        dependency.accessRules[3].kind == 0
        dependency.accessRules[3].pattern == 'literal-accessible'
        dependency.accessRules[4].kind == 1
        dependency.accessRules[4].pattern == 'literal-nonaccessible'
        dependency.accessRules[5].kind == 2