assertFalse(instance.isFileSystemCheckIgnoredFor(File("xyz/abc")))
    }

    @Test
    fun `recognizes relative paths against rootDirectory`() {
        val instance = createFromPaths(listOf("test/123"))
        assertTrue(instance.isFileSystemCheckIgnoredFor(rootDir.resolve("test/123")))
    }

    @Test
    fun `recognizes multiple paths`() {
        val instance = createFromPaths(listOf("path/one", "path/two"))

		in         []byte
		recognizes bool
	}{
		{
			in:         nil,
			recognizes: false,
		},
		{
			in:         []byte{},
			recognizes: false,
		},
		{
			in:         []byte{0xd9},
			recognizes: false,
		},
		{
			in:         []byte{0xd9, 0xd9},
			recognizes: false,
		},
		{
			in:         []byte{0xd9, 0xd9, 0xf7},
			recognizes: true,
		},
		{

	"k8s.io/apimachinery/pkg/runtime"
	"k8s.io/apimachinery/pkg/runtime/schema"
	"k8s.io/apimachinery/pkg/runtime/serializer/cbor/internal/modes"
	"k8s.io/apimachinery/pkg/runtime/serializer/recognizer"
	util "k8s.io/apimachinery/pkg/util/runtime"

	"github.com/fxamacker/cbor/v2"
)

type metaFactory interface {
	// Interpret should return the version and kind of the wire-format of the object.

     */
    String getStacktrace();

    /**
     * Returns true if the represented failure is recognized as an assertion failure.
     *
     * @return {@code true} for assertion failures
     */
    boolean isAssertionFailure();

    /**
     * Returns true if the represented failure is recognized as a file comparison failure.
     * <p>

    }

    def 'can recognize $build'() {
        expect:
        JavaVersion.toVersion('9+0') == JavaVersion.VERSION_1_9
        JavaVersion.toVersion('3.14+9999900') == JavaVersion.VERSION_1_3
        JavaVersion.toVersion('9-pre+105') == JavaVersion.VERSION_1_9
        JavaVersion.toVersion('6.0.42-8beta+4') == JavaVersion.VERSION_1_6
    }

    def 'can recognize version with $opt'() {
        expect:

        then:
        runtimeArtifacts.size() == compileArtifacts.size()
        defaultArtifacts.size() == runtimeArtifacts.size()
    }

    def "recognises pom packaging"() {
        when:
        def metadata = mavenMetadataFactory.create(id, [])
        metadata.packaging = packaging

        then:
        metadata.packaging == packaging

	switch c.goos {
	case "windows", "plan9", "android", "ios":
		return fallbackOrder, nil
	}

	// Try to figure out the order to use for searches.
	// If we don't recognize something, use fallbackOrder.
	// That will use cgo unless the Go resolver was explicitly requested.
	// If we do figure out the order, return something other
	// than fallbackOrder to use the Go resolver with that order.

		memmove(unsafe.Pointer(mp.notesig), unsafe.Pointer(note), uintptr(len(notestr)+1))
		gp.sig = uint32(sig)
		gp.sigpc = c.pc()

		pc := c.pc()
		sp := c.sp()

		// If we don't recognize the PC as code
		// but we do recognize the top pointer on the stack as code,
		// then assume this was a call to non-code and treat like
		// pc == 0, to make unwinding show the context.

			},
		},
		{
			name: "compile with storage environment should recognize functions available only in the storage environment",
			expressions: []string{
				"test() == true",
			},
			envType: environment.StoredExpressions,
		},
		{
			name: "compile with supported environment should not recognize functions available only in the storage environment",
			errorExpressions: map[string]string{

// convertible to complex64 without changing its value.
//
// The number represented by s must be of the form N, Ni, or N±Ni, where N stands
// for a floating-point number as recognized by [ParseFloat], and i is the imaginary
// component. If the second N is unsigned, a + sign is required between the two components
// as indicated by the ±. If the second N is NaN, only a + sign is accepted.