func.return %0 : tensor<4x128xf32>
  }

        '+'             | _
        '1+'            | _
        '1.2+'          | _
        '1.2.3+'        | _
        '1.2.3.+'       | _
        'abc+'          | _
        '(1.0.0,2.0.0]' | _
        '(1.0.0,2.0.0)' | _
    }

    @ToBeFixedForConfigurationCache(because = "Task.getProject() during execution")
    def "maps dependency on latest.integration to master branch"() {
        given:

  ) -> tensor<5x9x!quant.uniform<i8:f32, 2.000000e+00:-1>> {
  %0 = stablehlo.pad %arg0, %arg1, low = [0, 1], high = [2, 1], interior = [1, 2] : (
    tensor<2x3x!quant.uniform<i8:f32, 2.000000e+00:-1>>,
    tensor<!quant.uniform<i8:f32, 2.000000e+00:-1>>
  ) -> tensor<5x9x!quant.uniform<i8:f32, 2.000000e+00:-1>>
  return %0 : tensor<5x9x!quant.uniform<i8:f32, 2.000000e+00:-1>>
}
// CHECK-LABEL: pad_with_interior_padding

  }

  public void testOf1() {
    assertThat(ImmutableDoubleArray.of(0).asList()).containsExactly(0.0);
  }

  public void testOf2() {
    assertThat(ImmutableDoubleArray.of(0, 1).asList()).containsExactly(0.0, 1.0).inOrder();
  }

  public void testOf3() {
    assertThat(ImmutableDoubleArray.of(0, 1, 3).asList()).containsExactly(0.0, 1.0, 3.0).inOrder();
  }

  public void testOf4() {

  Eigen::ThreadPoolDevice device(&tp, tp.NumThreads());

  SplitsComp fn;

  fn.set_thread_pool(&device);
  // x = [[1, 2], [3, 4]]
  fn.arg0(0, 0) = 1;
  fn.arg0(0, 1) = 2;
  fn.arg0(1, 0) = 3;
  fn.arg0(1, 1) = 4;

  // y = [[10, 20], [30, 40]]
  fn.arg1(0, 0) = 10;
  fn.arg1(0, 1) = 20;
  fn.arg1(1, 0) = 30;
  fn.arg1(1, 1) = 40;
  EXPECT_TRUE(fn.Run());
  EXPECT_EQ(fn.error_msg(), "");

	}
}

type FloatInt struct {
	x float64
	y int
}

func TestGrowWithNegativeZero(t *testing.T) {
	negzero := math.Copysign(0.0, -1.0)
	m := make(map[FloatInt]int, 4)
	m[FloatInt{0.0, 0}] = 1
	m[FloatInt{0.0, 1}] += 2
	m[FloatInt{0.0, 2}] += 4
	m[FloatInt{0.0, 3}] = 8
	growflag := true
	s := 0
	cnt := 0
	negcnt := 0
	// The first iteration should return the +0 key.

  }

  public void testOf1() {
    assertThat(ImmutableDoubleArray.of(0).asList()).containsExactly(0.0);
  }

  public void testOf2() {
    assertThat(ImmutableDoubleArray.of(0, 1).asList()).containsExactly(0.0, 1.0).inOrder();
  }

  public void testOf3() {
    assertThat(ImmutableDoubleArray.of(0, 1, 3).asList()).containsExactly(0.0, 1.0, 3.0).inOrder();
  }

  public void testOf4() {

    assertThrows(IllegalArgumentException.class, () -> source.slice(-1, 10));

    assertThrows(IllegalArgumentException.class, () -> source.slice(0, -1));

    assertCorrectSlice(0, 0, 0, 0);
    assertCorrectSlice(0, 0, 1, 0);
    assertCorrectSlice(100, 0, 10, 10);
    assertCorrectSlice(100, 0, 100, 100);
    assertCorrectSlice(100, 5, 10, 10);
    assertCorrectSlice(100, 5, 100, 95);

	// therefore the bits will be in the reverse order. So normally one
	// would expect, say, 4*key to be in index 4 of the table but due to
	// this bit ordering it will actually be in index 0010 (base 2) = 2.
	x := gcmFieldElement{
		byteorder.BeUint64(key[:8]),
		byteorder.BeUint64(key[8:]),
	}
	g.productTable[reverseBits(1)] = x

	for i := 2; i < 16; i += 2 {

			orMask: "11",
		},
		{
			name:   "Mask 01 OR mask 10 OR mask 11",
			masks:  [][]int{{0}, {1}, {0, 1}},
			orMask: "11",
		},
		{
			name:   "Mask 1000 OR mask 0100 OR mask 0010 OR mask 0001",
			masks:  [][]int{{3}, {2}, {1}, {0}},
			orMask: "1111",
		},
	}
	for _, tc := range tcases {
		var bitMasks []BitMask
		for i := range tc.masks {