* Does not calculate the value on demand and does not block if the value is currently being calculated.
     *
     * <p>Rethrows any exception that happened while calculating the value</p>
     */
    T get() throws IllegalStateException;

    /**
     * Returns the result of calculating the value, failing if it has not been calculated.

	// WARNING: in.Target requires manual conversion: does not exist in peer-type
	// WARNING: in.MetricName requires manual conversion: does not exist in peer-type
	// WARNING: in.CurrentValue requires manual conversion: does not exist in peer-type
	// WARNING: in.Selector requires manual conversion: does not exist in peer-type
	// WARNING: in.AverageValue requires manual conversion: does not exist in peer-type
	return nil
}

        def collector = new FormattingValidationProblemCollector("<thing>", ModelType.of(String))
        collector.add("does not extend RuleSource")
        collector.add("does not have any rule method")

        expect:
        collector.format() == '''Type java.lang.String is not a valid <thing>:
- does not extend RuleSource
- does not have any rule method'''
    }

    static class SuperClass {
        private String value

    }

    def "does not select items when no matches"() {
        expect:
        doesNotMatch("name")
        doesNotMatch("name", "other")
        doesNotMatch("name", "na")
        doesNotMatch("sN", "otherName")
        doesNotMatch("sA", "someThing")
        doesNotMatch("soN", "saN")
        doesNotMatch("soN", "saName")
    }

    def "does not select items when multiple camel case matches"() {

	v6 = f4
	v7 = f4 // ERROR "inferred type func(int, int) for func(P, P) does not match type func(int, string) of v7"
	v8 = f5
	v9 = f5 // ERROR "inferred type func(string) []string for func(P) []P does not match type func(string) []int of v9"

	// non-trivial LHS
	var a [2]func(string) []int
	a[0] = f5 // ERROR "inferred type func(string) []string for func(P) []P does not match type func(string) []int of a[0]"
}

// Return statements

  if [[ ! -f ${tmp_pdf_file} ]] ; then
    echo "unoconv does not work."
    exit 1
  fi
  tmp_png_prefix=/tmp/thumbnail.png.$$
  pdftoppm -png -singlefile ${tmp_pdf_file} ${tmp_png_prefix}
  tmp_png_file="${tmp_png_prefix}.png"
  rm -f ${tmp_pdf_file}
  if [[ ! -f ${tmp_png_file} ]] ; then
    echo "pdftoppm does not work."
    exit 1
  fi

            stringInterner
        )
    }

    def "does suppress exceptions from load"() {
        given:
        1 * remote.load(key, _) >> { throw new RuntimeException() }

        when:
        controller.load(key, cacheableEntity)

        then:
        1 * local.loadLocally(key, _)
        0 * local.storeLocally(key, _)
    }

    def "does suppress exceptions from store"() {
        given:

func f0[T any](chan S[T]) {}

func _() {
	var x chan interface{ m(int) }
	f0(x /* ERROR "type chan interface{m(int)} of x does not match chan S[T] (cannot infer T)" */)
}

// variants of the theme

func f1[T any]([]S[T]) {}

func _() {
	var x []interface{ m(int) }
	f1(x /* ERROR "type []interface{m(int)} of x does not match []S[T] (cannot infer T)" */)
}

type I[T any] interface {
	m(T)
}

func f2[T any](func(I[T])) {}

package hash

import (
	"errors"
	"fmt"
)

// SHA256Mismatch - when content sha256 does not match with what was sent from client.
type SHA256Mismatch struct {
	ExpectedSHA256   string
	CalculatedSHA256 string
}

func (e SHA256Mismatch) Error() string {
	return "Bad sha256: Expected " + e.ExpectedSHA256 + " does not match calculated " + e.CalculatedSHA256
}

        versions.all*.version == versions.all*.version.sort().reverse()
    }

    def "get most recent final does that"() {
        when:
        props.mostRecent = "1.2"

        then:
        versions().mostRecentRelease.version == version("1.2")
    }

    def "get most recent snapshot does that"() {
        when:
        props.mostRecentSnapshot = "2.5-20150413220018+0000"

        then: