var zork = map[int]mazeRoom{
	11: {exits: [10]int{north: 11, south: 12, east: 14}}, // west to Troll Room
	12: {exits: [10]int{south: 11, north: 14, east: 13}},
	13: {exits: [10]int{west: 12, north: 14, up: 16}},
	14: {exits: [10]int{west: 13, north: 11, east: 15}},
	15: {exits: [10]int{south: 14}},                   // Dead End
	16: {exits: [10]int{east: 17, north: 13, sw: 18}}, // skeleton, etc.

     *
     * The missing cases of the when-expression in the following example are Direction.WEST and Direction.EAST:
     *
     * enum class Direction {
     *   NORTH, SOUTH, WEST, EAST
     * }
     * foo = when(direction) {
     *   Direction.NORTH -> 1
     *   Direction.SOUTH -> 2
     *   else -> 3
     * }
     *

interface Intf {
    fun run()
}

abstract class Ordinary

annotation class Anno

@Anno
class Generic<T> : Ordinary(), Intf {
    override fun run() {}
}

enum class Direction {
    NORTH, SOUTH, WEST, EAST
}

sealed class Operation {
    class Add(val firstValue: Int, val secondValue: Int) : Operation()
    class Subtract(val minuend: Int, val subtrahend: Int) : Operation()
    class Negate(val value: Int) : Operation()

        new URI("s3://somebucket.au.s3-ap-southeast-2.amazonaws.com/a/b/file.txt")    | Optional.of(getRegion(Regions.AP_SOUTHEAST_2))                      | 'somebucket.au' | 'a/b/file.txt'
        new URI("s3://somebucket.au.s3.cn-north-1.amazonaws.com.cn/a/b/file.txt")     | Optional.of(RegionUtils.getRegion(Region.CN_Beijing.firstRegionId)) | 'somebucket.au' | 'a/b/file.txt'

    private synthetic final static field $ENTRIES: kotlin.enums.EnumEntries
    private synthetic final static field $VALUES: Direction[]
    public final enum static field EAST: Direction
    public final enum static field NORTH: Direction
    public final enum static field SOUTH: Direction
    public final enum static field WEST: Direction
    private synthetic final static method $values(): Direction[]
    static method <clinit>(): void

        when:
        mapProperty.putAll(["forth": "value4", "fifth": "value5"])

        then:
        map == ["first": "value1", "second": "value2", "third": "value3", "forth": "value4", "fifth": "value5"]
        map.containsKey("first")
        map.containsKey("second")
        map.containsKey("third")
        map.containsKey("forth")
        map.containsKey("forth")
    }

        when:
        collection.removeAll { it in ["first", "third", "forth"] }

        then:
        property.get() == cast(["second", "fifth"])

        when:
        collection.addAll(["first", "third", "forth"])
        collection.retainAll { it in ["first", "third", "forth"] }

        then:
        property.get() == cast(["first", "third", "forth"])
    }

        list.size() == 5

        when:
        list.removeAll(["first", "third", "forth"])

        then:
        property.get() == ["second", "fifth"]
        list.size() == 2

        when:
        list.addAll(0, ["first", "third", "forth"])

        then:
        property.get() == ["first", "third", "forth", "second", "fifth"]
        list.size() == 5

        !parser.root
        !outsideOfRoot

        when:
        outsideOfRoot = parser.nextPath("tree-some/second/third/forth/", true, exitHandler)
        then:
        0 * exitHandler.run()
        then:
        parser.name == "forth"
        parser.relativePath == "second/third/forth"
        !parser.root
        !outsideOfRoot

        when:

        ->mutable_session_metadata()
        ->set_name(options.session_name);
  }

  // Call AddDevices to register the XLA devices.
  //
  // It may be worth refactoring out XlaOpRegistry::RegisterCompilationDevice to
  // make this more direct, but probably not worth it solely for this test.
  std::vector<std::unique_ptr<Device>> devices;
  TF_RETURN_IF_ERROR(DeviceFactory::AddDevices(session_options, "", &devices));