check[string]()
}

func check[T any]() {
	var result setter[T]
	switch result.(type) {
	case fooA[T]:
	case fooB[T]:
	}
}

type setter[T any] interface {
	Set(T)
}

type fooA[T any] struct{}

func (fooA[T]) Set(T) {}

type fooB[T any] struct{}

        when:
        availablePaths = ["fo", "bor", "for", "of", "foob"]

        then:
        suggestionsFor("foo") == ["fo", "foob", "for"]
        suggestionsFor("foor") == ["foob", "for", "bor", "fo"]
        suggestionsFor("foora") == ["foob", "for"]
    }

    def "suggestions are ordered by distance then alphabetical"() {
        when:

        matcher = RequirementMatcherFactory.createExactMatcher("foo");
        assertFalse(matcher.matches("bar"));
        assertFalse(matcher.matches("foobar"));
        assertFalse(matcher.matches("foob"));
        assertTrue(matcher.matches("foo"));
    }

    /**
     * Test of createVersionMatcher method, of class RequirementMatcherFactory.
     */
    @Test
    void testCreateVersionMatcher() {

			mh = append(mh, queues...)
		}
		sub.client = gwc
	}
	subPool.Put(sub)
}

func subjectStartsWithGatewayReplyPrefix(subj []byte) bool {
	return len(subj) > 8 && string(subj[:4]) == "foob"
}

func (c *client) gatewayInterest(acc, subj string) *SublistResult {
	ei, _ := c.gw.outsim.Load(acc)
	var r *SublistResult
	e := ei.(*outsie)
	r = e.sl.Match(subj)
	return r
}