given:
        details.candidateValues >> (["value1", "value2"] as Set)
        ruleChain.add(BrokenRule)

        when:
        ruleChain.execute(details)

        then:
        def e = thrown(AttributeMatchException)
        e.message == 'Could not select value from candidates [value1, value2] using DefaultDisambiguationRuleChainTest.BrokenRule.'
        e.cause == BrokenRule.failure

  %value1 = "tf.LookupTableFindV2"(%handle, %key1, %default) {device = "/job:localhost/replica:0/task:0/device:CPU:0"} : (tensor<!tf_type.resource>, tensor<!tf_type.string>, tensor<i64>) -> tensor<i64>
  func.return %value0, %value1 : tensor<i64>, tensor<i64>
}

func.func private @else_branch(%arg0: tensor<i1>) -> tensor<i1> {

        then:
        output.contains """
Options
     --valueA     descA

     --no-valueA     Disables option --valueA.

     --valueB     descB

     --no-valueB     Disables option --valueB.

     --valueC     descC

     --no-valueC     Disables option --valueC."""
    }

			ObjectMeta: metav1.ObjectMeta{
				Name:      "le-config",
				Namespace: "le-namespace",
				Labels: map[string]string{
					"label1": "value1",
					"label2": "value2",
				},
				Annotations: map[string]string{
					"annotation1": "value1",
					"annotation2": "value2",
				},
			},
			Data: map[string]string{
				"foo": "bar",
			},
			BinaryData: map[string][]byte{
				"bar": []byte("baz"),
			},

      Key key1 = new Key(1);
      String value1 = key1.toString();
      Key key2 = new Key(2);
      String value2 = key2.toString();
      assertSame(value1, cache.getUnchecked(key1));
      assertSame(value2, cache.getUnchecked(key2));
      assertEquals(ImmutableSet.of(key1, key2), cache.asMap().keySet());
      assertThat(cache.asMap().values()).containsExactly(value1, value2);
      assertEquals(

		t.Skip("Skipping test that fails on Windows")
	}

	labels1 := map[string]string{
		"key1": "value1",
		"key2": "value2",
	}
	labels2 := map[string]string{
		"key1": "value1",
		"key2": "value2",
		"key3": "value3",
	}
	annotations := map[string]string{
		"a1":        "value1",
		"a2":        "value2",
		"multiline": "c\nb\na",
	}
	testCases := []struct {
		name           string

        then:
        failureCauseContains("No tests found for given includes: [SubClass.$testMethod](--tests filter)")

        where:
        testMethod << ["sub unrolled test param=value1", "super unrolled test param=value1", "super super unrolled test param=value1"]
    }

				if s.Value[0] == 0 {
					return nil, nil, fmt.Errorf("parsing sample %s: second value must be non-zero", line)
				}
				s.NumLabel = map[string][]int64{"bytes": {s.Value[1] / s.Value[0]}}
				s.Value[0], s.Value[1] = scaleHeapSample(s.Value[0], s.Value[1], javaHeapzSamplingRate)
			case "contention":
				if period := p.Period; period != 0 {
					s.Value[0] = s.Value[0] * p.Period

	// test AddAnnotation
	attr.AddAnnotation("foo.admission.k8s.io/key1", "value1")
	attr.AddAnnotation("foo.admission.k8s.io/key2", "value2")
	annotations := attr.getAnnotations(auditinternal.LevelMetadata)
	assert.Equal(t, annotations["foo.admission.k8s.io/key1"], "value1")

	// test overwrite
	assert.Error(t, attr.AddAnnotation("foo.admission.k8s.io/key1", "value1-overwrite"),
		"admission annotations should not be allowd to be overwritten")

        """
import java.io.Serializable;

public class CustomType implements Serializable {
    public String value;

    public CustomType(String value) { this.value = value; }

    public boolean equals(Object o) {
        CustomType other = (CustomType)o;
        return other.value.startsWith(value) || value.startsWith(other.value);
    }