// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

func main() {
	type name string
	_ = []byte("abc", "def", 12)    // ERROR "too many arguments (to conversion to \[\]byte: \(\[\]byte\)\(.abc., .def., 12\))?"
	_ = string("a", "b", nil)       // ERROR "too many arguments (to conversion to string: string\(.a., .b., nil\))?"

	case 5.0: // ERROR "duplicate case (5 in switch)?"
	}
}

func f2(s string) {
	switch s {
	case "":
	case "": // ERROR "duplicate case (.. in switch)?"
	case "abc":
	case "abc": // ERROR "duplicate case (.abc. in switch)?"
	}
}

func f3(e interface{}) {
	switch e {
	case 0:
	case 0: // ERROR "duplicate case (0 in switch)?"
	case int64(0):
	case float32(10):

	fmt.Println(path.Join("", "a"))

	// Output:
	// a/b/c
	// a/b/c
	// a/b/c
	// ../xyz
	//
	// a
	// a
}

func ExampleMatch() {
	fmt.Println(path.Match("abc", "abc"))
	fmt.Println(path.Match("a*", "abc"))
	fmt.Println(path.Match("a*/b", "a/c/b"))
	// Output:
	// true <nil>
	// true <nil>
	// false <nil>
}

func ExampleSplit() {
	split := func(s string) {

	puts	(s string) string;
}

// ---------

type	Print	struct {
	whoami	int;
	put	Iputs;
}

func (p *Print) dop() string {
	r := " print " + string(p.whoami + '0')
	return r + p.put.puts("abc");
}

// ---------

type	Bio	struct {
	whoami	int;
	put	Iputs;
}

func (b *Bio) puts(s string) string {
	r := " bio " + string(b.whoami + '0')
	return r + b.put.puts(s);
}

// ---------

	a := A[int]{B: B[int]{3}}
	var i getter[int] = &a

	if got, want := doGet(i), 3; got != want {
		panic(fmt.Sprintf("got %v, want %v", got, want))
	}

	as := A[string]{B: B[string]{"abc"}}
	if got, want := doGet2[string](&as), "abc"; got != want {
		panic(fmt.Sprintf("got %v, want %v", got, want))
	}

		length      int
		resExpected string
		errExpected error
	}{
		{"abcd", 1, 1, "a", nil},
		{"abcd", -1, 1, "a", nil},
		{"abcd", 999, 999, "", nil},
		{"", 999, 999, "", nil},
		{"测试abc", 1, 1, "测", nil},
		{"测试abc", 5, 5, "c", nil},
	}

	for i, tc := range evalCases {
		res, err := evalSQLSubstring(tc.s, tc.startIdx, tc.length)
		if res != tc.resExpected || err != tc.errExpected {

	testCases := []struct {
		etag              string
		canonicalizedETag string
	}{
		{
			etag:              "\"\"\"",
			canonicalizedETag: "",
		},
		{
			etag:              "\"\"\"abc\"",
			canonicalizedETag: "abc",
		},
		{
			etag:              "abcd",
			canonicalizedETag: "abcd",
		},
		{
			etag:              "abcd\"\"",
			canonicalizedETag: "abcd",
		},
	}
	for _, test := range testCases {

        "DirectoryProperty"           | "objects.directoryProperty()"         | "file('abc')"        | new File('abc')
        "DirectoryProperty"           | "objects.directoryProperty()"         | "null"               | "null"
        "RegularFileProperty"         | "objects.fileProperty()"              | "file('abc')"        | new File('abc')

        TaskDetails task4 = taskDetails('task4')
        TaskDetails task5 = taskDetails('task5')

        _ * target.groups >> (['Abc', 'a', 'A', '', 'Other'] as LinkedHashSet)
        _ * target.getTasksForGroup('a') >> [task1]
        _ * target.getTasksForGroup('A') >> [task2]
        _ * target.getTasksForGroup('Abc') >> [task3]
        _ * target.getTasksForGroup('') >> [task4]
        _ * target.getTasksForGroup('Other') >> [task5]

    assertEquals(java.util.Optional.of("abc"), Optional.toJavaUtil(Optional.of("abc")));
  }

  public void testToJavaUtil_instance() {
    assertEquals(java.util.Optional.empty(), Optional.absent().toJavaUtil());
    assertEquals(java.util.Optional.of("abc"), Optional.of("abc").toJavaUtil());
  }

  public void testFromJavaUtil() {
    assertNull(Optional.fromJavaUtil(null));