// CHECK-SAME: %[[ARG0:.*]]: tensor<1x2xf32>
  // CHECK-SAME: %[[ARG1:.*]]: tensor<2x3xf32>
  // CHECK-SAME: %[[ARG2:.*]]: tensor<1x3xi1>
  // CHECK-SAME: %[[ARG3:.*]]: tensor<1x3xf32>
  func.func private @composite_and_select(%arg0: tensor<1x2xf32>, %arg1: tensor<2x3xf32>, %arg2: tensor<1x3xi1>, %arg3: tensor<1x3xf32>) -> tensor<1x3xf32> {

						Address: &core.Address{
							Address: &core.Address_SocketAddress{
								SocketAddress: &core.SocketAddress{
									Address: "10.0.0.1",
								},
							},
						},
					},
				},
			},
			want: "10.0.0.1",
		},
		{
			name: "internal address",
			endpoint: &endpoint.LbEndpoint{
				HostIdentifier: &endpoint.LbEndpoint_Endpoint{
					Endpoint: &endpoint.Endpoint{

	saB := "serviceaccountB"
	saC := "spiffe://accounts.google.com/******@****.***"
	saD := "spiffe://accounts.google.com/******@****.***"

	ip := "10.0.0.1"

	tnow := time.Now()
	localSvc := corev1.Service{
		ObjectMeta: metav1.ObjectMeta{
			Name:      serviceName,
			Namespace: namespace,
			Annotations: map[string]string{

        if (expired) {
            // should check that the recorded service call returns the same value
            1 * record.getInput() >> '124'
            1 * record.getOutput() >> HashCode.fromInt(10000)
            1 * cachedResult.isChanging() >> changing
            1 * cachedResult.getId() >> id
            1 * cachePolicy.moduleExpiry({ it.id == id }, Duration.ZERO, changing) >> Stub(Expiry) {

		},
		{
			"handSize <= 0",
			100,
			0,
			fmt.Errorf("deckSize 100 or handSize 0 is not positive"),
		},
		{
			"handSize is greater than deckSize",
			100,
			101,
			fmt.Errorf("handSize 101 is greater than deckSize 100"),
		},
		{
			"deckSize is impractically large",
			1 << 27,
			2,
			fmt.Errorf("deckSize 134217728 is impractically large"),
		},
		{

	96:          {_SigNotify, "signal 96"},
	97:          {_SigNotify, "signal 97"},
	98:          {_SigNotify, "signal 98"},
	99:          {_SigNotify, "signal 99"},
	100:         {_SigNotify, "signal 100"},
	101:         {_SigNotify, "signal 101"},
	102:         {_SigNotify, "signal 102"},
	103:         {_SigNotify, "signal 103"},
	104:         {_SigNotify, "signal 104"},
	105:         {_SigNotify, "signal 105"},

            .ticker(fakeTicker)
            .build();

    cache.put(654, 2675);
    fakeTicker.advance(10000, TimeUnit.MILLISECONDS);
    cache.put(2456, 56);
    cache.put(2, 15);

    fakeTicker.advance(10001, TimeUnit.MILLISECONDS);

    assertTrue(cache.asMap().containsValue(15));
    assertTrue(cache.asMap().containsValue(56));
    assertFalse(cache.asMap().containsValue(2675));
  }

        assertEquals(num, valueSet2.size());
    }

    @Test
    public void test_getLimitDocNum() throws Exception {
        assertEquals(10, ESSourceReader.getLimitDocNum(100, 10, -1));
        assertEquals(25, ESSourceReader.getLimitDocNum(50, 50, -1));
        assertEquals(10, ESSourceReader.getLimitDocNum(50, 50, 10));
    }

    @Test
    public void test_sort() throws Exception {

			t.Errorf("Expected error parsing: %q", v)
		}
	}
	checkError("10.0.0.1/33")
	checkError("foo.bar")
	checkError("10.0.0.1/32,*")
	checkError("10.0.0.1/32,")
	checkError("10.0.0.1/32, ")
	checkError("10.0.0.1")

	checkOK := func(v string) utilnet.IPNetSet {
		t.Helper()
		annotations := make(map[string]string)
		annotations[api.AnnotationLoadBalancerSourceRangesKey] = v
		svc := api.Service{}

        if (expired) {
            // should check that the recorded service call returns the same value
            1 * record.getInput() >> '124'
            1 * record.getOutput() >> TestHashCodes.hashCodeFrom(10000)
            1 * cachedResult.isChanging() >> changing
            1 * cachedResult.getModuleVersionId() >> id
            1 * cachePolicy.moduleExpiry({ it.id == id }, Duration.ZERO, changing) >> Stub(Expiry) {