val imports = listOf(
            importOf("a", "b", "C"),
            importOf("a", "b", "c", "d")
        )
        val analysisContext = testContext()
        val result = defaultCodeResolver().collectImports(imports, analysisContext)

        assertEquals(
            mapOf(
                "C" to DefaultFqName("a.b", "C"),
                "d" to DefaultFqName("a.b.c", "d")
            ),
            result
        )

	}
	if !s.HasAll("a", "b") {
		t.Errorf("Missing contents: %#v", s)
	}
	s2.Insert("a", "b", "d")
	if s.IsSuperset(s2) {
		t.Errorf("Unexpected contents: %#v", s)
	}
	s2.Delete("d")
	if !s.IsSuperset(s2) {
		t.Errorf("Missing contents: %#v", s)
	}
}

func TestSetDeleteMultiples(t *testing.T) {
	s := sets.Set[string]{}
	s.Insert("a", "b", "c")
	if len(s) != 3 {
		t.Errorf("Expected len=3: %d", len(s))
	}

// The result will be 0 if a == b, -1 if a < b, and +1 if a > b.
//
// Use Compare when you need to perform a three-way comparison (with
// slices.SortFunc, for example). It is usually clearer and always faster
// to use the built-in string comparison operators ==, <, >, and so on.
func Compare(a, b string) int {
	return bytealg.CompareString(a, b)

}

//go:noinline
func f2(a, b int) bool {
	x := true
	if a == b {
		x = false
	}
	return x // ERROR "converted OpPhi to Not$"
}

//go:noinline
func f3(a, b int) bool {
	x := false
	if a == b {
		x = true
	}
	return x // ERROR "converted OpPhi to Copy$"
}

//go:noinline
func f4(a, b bool) bool {
	return a || b // ERROR "converted OpPhi to OrB$"
}

//go:noinline

		if !ok {
			return t, false
		}
		return join(t1, t2), true
	}
}

type Pair[A, B any] struct {
	A A
	B B
}

func _NewPair[A, B any](a A, b B) Pair[A, B] {
	return Pair[A, B]{a, b}
}

func Combine2[A, B any](ga Gen[A], gb Gen[B]) Gen[Pair[A, B]] {
	return Combine(ga, gb, _NewPair[A, B])
}

func main() {
	var g1 Gen[int] = func() (int, bool) { return 3, true }

        BiAction<List<String>, List<String>> first = {a, b -> a << "first a"; b << "first b" }
        BiAction<List<String>, List<String>> second = {a, b -> a << "second a"; b << "second b" }
        def composite = BiActions.composite(first, second)
        def a = []
        def b = []

        when:
        composite.execute(a, b)

        then:
        a == ["first a", "second a"]
        b == ["first b", "second b"]
    }

    def "escapes backslash in argument"() {
        when:
        argWriter.args('a\\b', 'a \\ bc')

        then:
        writer.toString() == toPlatformLineSeparators('a\\\\b "a \\\\ bc"\n')
    }

    def "does not escape characters in windows style"() {
        def argWriter = ArgWriter.windowsStyle(printWriter)

        when:
        argWriter.args('a\\b', 'a "\\" bc')

        then:

KaDataFlowExitPointSnapshot:
  defaultExpressionInfo = DefaultExpressionInfo:
    expression = if (a + b > 0) break
            else {
                consume(a - b)
                if (a - b > 0) break else consume(a + b)
            }
    type = kotlin.Unit
  hasEscapingJumps = true
  hasJumps = true
  hasMultipleJumpKinds = false
  hasMultipleJumpTargets = false
  jumpExpressions = [
    break,
    break
  ]
  returnValueType = null

        expect:
        canCompareTwoVersions(a, b)

        where:
        a      | b
        '0.9'  | '0.8'
        '1.0'  | '0.10'
        '10.0' | '2.1'
        '2.5'  | '2.4'
    }

    def canComparePointVersions() {
        expect:
        canCompareTwoVersions(a, b)

        where:
        a                   | b
        '0.9.2'             | '0.9.1'

}

func ExampleJoin() {
	fmt.Println("On Unix:")
	fmt.Println(filepath.Join("a", "b", "c"))
	fmt.Println(filepath.Join("a", "b/c"))
	fmt.Println(filepath.Join("a/b", "c"))
	fmt.Println(filepath.Join("a/b", "/c"))

	fmt.Println(filepath.Join("a/b", "../../../xyz"))

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

func ExampleMatch() {
	fmt.Println("On Unix:")