def dir3 = new File("dir3").absoluteFile

        System.setProperty("gradle.user.home", "dir1")

        def parameters1 = convert([])
        def parameters2 = convert(["-Dgradle.user.home=dir2"])
        def parameters3 = convert(["--gradle-user-home", "dir3", "-Dgradle.user.home=dir2"])

        then:
        parameters1.gradleUserHomeDir == dir1
        parameters2.gradleUserHomeDir == dir2

        expect:
        def result = event.convert("")
        result.response == 4
        result.newPrompt == null
    }

    def "can have negative minimum value"() {
        def event = new IntQuestionPromptEvent(123, "question?", -5, -2)

        expect:
        def result = event.convert(input)
        result.response == expected
        result.newPrompt == null

// array-literal conversion

package main

func main() {
	_ = []byte{"foo"}   // ERROR "cannot use|incompatible type|cannot convert"
	_ = []int{"foo"}    // ERROR "cannot use|incompatible type|cannot convert"
	_ = []rune{"foo"}   // ERROR "cannot use|incompatible type|cannot convert"
	_ = []string{"foo"} // OK

    def "converts notation"() {
        given:
        converter.convert(12, _) >> { Object notation, NotationConvertResult result -> result.converted("12") }

        expect:
        parser.parseNotation(12) == "12"
    }

    def "can convert to null value"() {
        given:
        converter.convert(12, _) >> { Object notation, NotationConvertResult result -> result.converted(null) }

        expect:

  if [[ ! -f ${tmp_png_file} ]] ; then
    echo "pdftoppm does not work."
    exit 1
  fi
  convert -thumbnail ${image_size} ${tmp_png_file} "${output_file}"
  rm -f ${tmp_png_prefix}*png
elif [[ x"${cmd_type}" = "ximage" ]] ; then
  check_command convert
  target_file=$(echo "$url" | sed -e "s#^file:/*#/#g")
  convert -thumbnail ${image_size} "${target_file}" "${output_file}"
elif [[ x"${cmd_type}" = "x" ]] ; then

	var t T
	var u struct {
		x E2 "bar"
	}
	s = s
	s = t // ERRORx `cannot use .* in assignment`
	s = u // ERRORx `cannot use .* in assignment`
	s = S(s)
	s = S(t /* ERROR "cannot convert" */ )
	s = S(u /* ERROR "cannot convert" */ )
	t = u   // ERRORx `cannot use .* in assignment`
	t = T(u)
}

func _() {
	type E struct{ x int }
	type S struct {
		f func(struct {
			x int "foo"
		})
	}

func main() {
	var b [0]byte
	s := string(b[0:]) // out of bounds trap
	if s != "" {
		panic("bad convert")
	}
	var b1 = [5]byte{'h', 'e', 'l', 'l', 'o'}
	if string(b1[0:]) != "hello" {
		panic("bad convert 1")
	}
	var b2 = make([]byte, 5)
	for i := 0; i < 5; i++ {
		b2[i] = b1[i]
	}
	if string(b2) != "hello" {
		panic("bad convert 2")
	}

var t []int
var s string;
var m map[string]int;

func main() {
	println(t["hi"]); // ERROR "non-integer slice index|must be integer|cannot convert"
	println(s["hi"]); // ERROR "non-integer string index|must be integer|cannot convert"
	println(m[0]);    // ERROR "cannot use.*as type string|cannot convert|cannot use"

      return Ascii.toLowerCase(word);
    }

    @Override
    String convert(CaseFormat format, String s) {
      if (format == LOWER_UNDERSCORE) {
        return s.replace('-', '_');
      }
      if (format == UPPER_UNDERSCORE) {
        return Ascii.toUpperCase(s.replace('-', '_'));
      }
      return super.convert(format, s);
    }
  },

  /** C++ variable naming convention, e.g., "lower_underscore". */

	float32(max32 + ulp32/2),                 // ERROR "constant 3\.40282e\+38 overflows float32|cannot convert.*to type float32"

	float32(-max32 - ulp32/2 + 1),             // ok
	float32(-max32 - ulp32/2 + two128/two256), // ok
	float32(-max32 - ulp32/2),                 // ERROR "constant -3\.40282e\+38 overflows float32|cannot convert.*to type float32"

	// If the compiler's internal floating point representation