wantFields:      "ok1,ok2,ok3\n" + `a word,"b"""` + "\n",
			wantErr:         io.EOF,
		},
		{
			// This works since LazyQuotes is true:
			file:            "invalid-badstartline.csv",
			recordDelimiter: "\n",
			fieldDelimiter:  ",",
			sendErr:         nil,
			header:          true,
			wantColumns:     []string{"header1", "header2", "header3"},

// All invalid semantic version strings compare equal to each other.
func Compare(v, w string) int {
	pv, ok1 := parse(v)
	pw, ok2 := parse(w)
	if !ok1 && !ok2 {
		return 0
	}
	if !ok1 {
		return -1
	}
	if !ok2 {
		return +1
	}
	if c := compareInt(pv.major, pw.major); c != 0 {
		return c
	}
	if c := compareInt(pv.minor, pw.minor); c != 0 {
		return c
	}

	i.collectionReporter(col)
	k := key{col, name, "default"}
	if result, ok := i.found[k]; ok {
		return result
	}
	if cache, ok := i.foundCollections[col]; ok {
		if result, ok2 := cache[k]; ok2 {
			return result
		}
	}
	colschema, ok := collections.All.FindByGroupVersionKind(col)
	if !ok {
		log.Warnf("collection %s could not be found", col.String())
		return nil
	}

    }

    @Test
    public void ok2() {
    }
}
        """
        file("src/integTest/java/org/example/SomeIntegTestClass.java") << """
package org.example;

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.Tag;

@Tag("fast")
public class SomeIntegTestClass {
    @Test
    public void ok1() {
    }

    @Test
    public void ok2() {
    }
}
        """
    }

    @Test(expectedExceptions = RuntimeException)
    public void ok() {
        throw new RuntimeException()
    }
}

public class ATestNGClassWithManyMethods {
    @Test public void ok() {}
    @Test public void ok2() {}
    @Test public void another() {}
    @Test public void yetAnother() {}
}

public class ATestNGClassWithGroups {
    @Test(groups="group1") public void group1() {}

                    fail("failed");
                }

                @Test
                public void ok() {
                }

                @Test
                public void ok2() {
                }
            }
        """.stripIndent()
        file('src/test/java/org/gradle/UnserializableException.java') << """
            package org.gradle;

            ${testFrameworkImports}

		t.Run("", func(t *testing.T) {
			fi, err := findFileInfoInQuorum(context.Background(), test.fis, test.modTime, "", test.expectedQuorum)
			_, ok1 := err.(InsufficientReadQuorum)
			_, ok2 := test.expectedErr.(InsufficientReadQuorum)
			if ok1 != ok2 {
				t.Errorf("Expected %s, got %s", test.expectedErr, err)
			}
			if test.succmodTimes != nil {
				if !test.expectedSuccModTime.Equal(fi.SuccessorModTime) {

func (sm *siteResyncMetrics) status(dID string) (rs SiteResyncStatus, err error) {
	sm.RLock()
	defer sm.RUnlock()
	if rst, ok1 := sm.peerResyncMap[dID]; ok1 {
		if st, ok2 := sm.resyncStatus[rst.resyncID]; ok2 {
			return st.clone(), nil
		}
	}
	return rs, errSRNoResync
}

// Status returns latest resync status for this deployment

)

// Various more complex expressions
var (
	u1 = x /* ERROR "not an interface" */ .(int)
	u2 = iface.([]int)
	u3 = iface.(a /* ERROR "not a type" */ )
	u4, ok = iface.(int)
	u5, ok2, ok3 = iface /* ERROR "assignment mismatch" */ .(int)
)

// Constant expression initializations
var (
	v1 = 1 /* ERROR "mismatched types untyped int and untyped string" */ + "foo"
	v2 = c + 255

	case reflect.Map:
		numElems := rand.Intn(size)
		v.Set(reflect.MakeMap(concrete))
		for i := 0; i < numElems; i++ {
			key, ok1 := sizedValue(concrete.Key(), rand, size)
			value, ok2 := sizedValue(concrete.Elem(), rand, size)
			if !ok1 || !ok2 {
				return reflect.Value{}, false
			}
			v.SetMapIndex(key, value)
		}
	case reflect.Pointer:
		if rand.Intn(size) == 0 {
			v.SetZero() // Generate nil pointer.