XdsPodPort int

	// CertDir is the local directory containing certificates
	CertDir string

	// Timeout is how long to wait before giving up on XDS
	Timeout time.Duration

	// InsecureSkipVerify skips client verification the server's certificate chain and host name.
	InsecureSkipVerify bool

	// XDSSAN is the expected Subject Alternative Name of the XDS server
	XDSSAN string

            testing {
                suites {
                    test {
                        useTestNG('${version}')
                    }
                }
            }
        """
    }

    def "skips tests after a config method failure by default"() {
        expect:
        fails "test"

        and:
        testResults.assertConfigMethodFailed("fail")
        testResults.assertTestSkipped("someTest")
    }

     *
     * @throws EOFException when the end of the byte stream is reached before the byte array was fully read.
     */
    byte[] readBinary() throws EOFException, IOException;

    /**
     * Skips the given number of bytes. Can skip over any byte values that were written using one of the raw byte methods on {@link Encoder}.
     */
    void skipBytes(long count) throws EOFException, IOException;

    /**

// with an error if something went wrong during directory/file
// reading.
//
// CollectPods skips over any file that is not related to coverage
// (e.g. avoids looking at things that are not meta-data files or
// counter-data files). CollectPods also skips over 'orphaned' counter
// data files (e.g. counter data files for which we can't find the

					record[i] = strings.ReplaceAll(s, "\r\n", "\n")
				}
			}
			// Note that the reader parses the quoted record "" as an empty string,
			// and the writer turns that into an empty line, which the reader skips over.
			// Filter those out to avoid false positives.
			records = slices.DeleteFunc(records, func(record []string) bool {
				return len(record) == 1 && record[0] == ""
			})

 * Also, because the transform does not use the value content, this provider also skips checks to verify that the content has been built when the value is queried.</p>
 *
 * @see ProviderInternal for a discussion of the "value" and "value contents".
 */

			t.Settings().Ambient = true
			return nil
		}).
		Setup(istio.Setup(&i, func(ctx resource.Context, cfg *istio.Config) {
			// can't deploy VMs without eastwest gateway
			ctx.Settings().SkipVMs()
			cfg.EnableCNI = true
			cfg.DeployEastWestGW = false
			cfg.ControlPlaneValues = `
values:
  cni:
    repair:
      enabled: true
  ztunnel:
    terminationGracePeriodSeconds: 5
    env:

}

// isStandard reports whether path is a standard library for gccgo.
func (gd *gccgoDirs) isStandard(path string) bool {
	// Quick check: if the first path component has a '.', it's not
	// in the standard library. This skips most GOPATH directories.
	i := strings.Index(path, "/")
	if i < 0 {
		i = len(path)
	}
	if strings.Contains(path[:i], ".") {
		return false
	}

	if path == "unsafe" {
		// Special case.

        new SkipEmptyIncrementalWorkStep(
            outputChangeListener,
            workInputListeners,
            { -> outputsCleaner },
            delegate)
    }

    def "skips when work has empty sources and previous outputs (#description)"() {
        def previousOutputFile = file("output.txt").createFile()
        def outputFileSnapshot = snapshot(previousOutputFile)

        when:

			return true
		}
	}
	return false
}

func matchSingle(filter testFilter, testName string) bool {
	if len(filter) == 0 {
		// No regex defined, we default to NOT matching. This ensures our default skips nothing
		return false
	}
	elem := strings.Split(testName, "/")
	if len(filter) > len(elem) {
		return false
	}
	for i, s := range elem {
		if i >= len(filter) {
			break
		}