Kotlin 停车场项目错误：使用扫描仪时。非接触性异常

我会感谢你的帮助。 我一直在做一个课程项目，在那里我必须建造一个停车场来登记车辆。当我在IDE中使用它时，它可以正常工作，但是当我运行它通过平台测试时，在第一个测试中，没有问题，但是当第二次迭代到达createOrder乐趣中的“When（val command=scanner.next（））”时，它崩溃并出现错误：

java.lang.AssertionError: Exception in test #1

Probably your program run out of input (Scanner tried to read more than expected).

java.util.NoSuchElementException
    at java.util.Scanner.throwFor(Scanner.java:862)
    at java.util.Scanner.next(Scanner.java:1371)
    at parking.ParkingLot.createOrder(Main.kt:39)
    at parking.ParkingLot.start(Main.kt:31)
    at parking.MainKt.main(Main.kt:6)
    at parking.MainKt.main(Main.kt)

Please find below the output of your program during this failed test.
Note that the '>' character indicates the beginning of the input line.

---

> park KA-01-HH-1234 White
White car parked in spot 1.

这个想法是，测试输入了许多汽车，但当试图进行第二次输入时，它崩溃了

这是我的代码（对不起，如果我的代码很乱，我还在学习）

导入java.util*
主要内容（）{
停车场开始
}
类别汽车（val regNumber:String=“”，val color:String=“”）{
}
类顺序（val命令：字符串）{
lateinit var regNum:字符串
lateinit变量颜色：字符串
lateinit变量spot:String
lateinit变量状态：字符串
}
目标停车场{
val空间：Array=Array（20）{Pair（null，null）}
const val occulated=“已占用”
const val park=“公园”
const val leave=“离开”
const val exit=“退出”
有趣的开始{
val scanner=扫描仪（系统.`in`）
做{
val order=createOrder（扫描仪）
交互（订单、扫描仪）
}while（order.command！=退出）
}
fun createOrder（扫描仪：扫描仪）：订单{
当（val命令=scanner.next（））{
公园->{
val parkOrder=订单（命令）
parkOrder.regNum=scanner.next（）
parkOrder.color=scanner.next（）
parkOrder.status=“有效”
退货订单
}
离开->{
val retrieveOrder=订单（命令）
retrieveOrder.spot=scanner.next（）
retrieveOrder.status=“有效”
返回检索订单
}
退出->{
val exitOrder=订单（命令）
exitOrder.status=“有效”
返回输出器
}
其他->{
val incorrector=顺序（命令）
incorrector.status=“无效”
返回不更正器
}
}
}
趣味互动（订单：订单，扫描仪：扫描仪）{
如果（order.command==park）{
//val toParkCar=Car（order.regNum，order.color）
停车场（汽车（order.regNum，order.color））
}
如果（order.command==离开）{
请假（订单）
}
如果（order.command==exit）返回
//TODO更新错误消息以包含exit命令
如果（order.status==“invalid”）println（“${order.command}\”无效，请使用“park\”或“leave\”）
//scanner.close（）
}
游乐场（汽车：汽车）{
用于空格中的（（索引，项）。withIndex（）{
如果（item.first==null）{
空间[索引]=对（已占用，汽车）
println（${car.color}停在现场${index+1}的汽车）
返回
}
}
println（“对不起，停车场已经满了。”）
}
娱乐假（订单：订单）{
if（空格[order.spot.toInt（）-1].first==已占用）{
空格[order.spot.toInt（）-1]=Pair（null，null）
println（“Spot${order.Spot}是免费的。”）
}否则{
println（“spot${order.spot}中没有汽车。”）
}
}
} 

好的，所以我注意到这是JetBrains插件的一个问题。我不知道为什么，但解决方案是将扫描器从函数中取出，直接放在主循环中。

您是否有包含生成“java.lang.AssertionError:Exception in test#1”的断言的代码？通常，断言的出现是为了告诉您一些特定的信息，因为它正在测试某些信息是否正确。如果您知道断言失败的地方，那么关键信息可能是它所断言的内容……也就是说，断言语句中的布尔表达式是什么？如果您找到此断言代码，请将其添加到您的问题中。另外，您是否有错误消息附带的堆栈跟踪？如果是这样的话，请把它放在你的问题中。好的，我将添加堆栈跟踪。如果这是一个愚蠢的问题，我很抱歉，但是断言是什么？我如何得到它？断言语句是您在代码中添加的，用于再次检查您所做的假设。它们不会（或者至少不应该）影响程序的逻辑。他们会让你知道你对代码运行方式的假设是否属实，你是如何将输入输入输入到你的程序中的。问题是代码告诉你什么…你没有给它足够的输入吗？哦，好吧，我没有重复检查。我用“scanner.hasNext（）”试过了，但没用。测试提供了输入，我不确定它是如何做到的

import java.util.*

fun main() {
    ParkingLot.start()
}

class Car(val regNumber: String = "", val color: String = "") {

}

class Order(val command: String) {
    lateinit var regNum: String
    lateinit var color: String
    lateinit var spot: String
    lateinit var status: String

}

object ParkingLot {
    val spaces: Array<Pair<String?, Car?>> = Array(20) { Pair(null, null) }
    const val occupied = "occupied"
    const val park = "park"
    const val leave = "leave"
    const val exit = "exit"

    fun start() {
        val scanner = Scanner(System.`in`)
        do {
            val order = createOrder(scanner)
            interaction(order, scanner)
        } while (order.command != exit)
    }

   fun createOrder(scanner: Scanner): Order {

        when (val command = scanner.next()) {
            park -> {
                val parkOrder = Order(command)
                parkOrder.regNum = scanner.next()
                parkOrder.color = scanner.next()
                parkOrder.status = "valid"
                return parkOrder
            }
            leave -> {
                val retrieveOrder = Order(command)
                retrieveOrder.spot = scanner.next()
                retrieveOrder.status = "valid"
                return retrieveOrder
            }
            exit -> {
                val exitOrder = Order(command)
                exitOrder.status = "valid"
                return exitOrder
            }

            else -> {
                val incorrectOrder = Order(command)
                incorrectOrder.status = "invalid"
                return incorrectOrder
            }
        }
    }


    fun interaction(order: Order, scanner: Scanner) {

        if (order.command == park) {
//            val toParkCar = Car(order.regNum, order.color)
            park(Car(order.regNum, order.color))
        }
        if (order.command == leave) {
            leave(order)
        }
        if (order.command == exit) return
//TODO update the error msg to include exit command
        if (order.status == "invalid") println("\"${order.command}\" isn't a valid , either use \"park\" or \"leave\"")
//        scanner.close()
    }

    fun park(car: Car) {
        for ((index, item) in spaces.withIndex()) {
            if (item.first == null) {
                spaces[index] = Pair(occupied, car)
                println("${car.color} car parked in spot ${index + 1}.")
                return
            }
        }
        println("Sorry, the parking lot is full.")
    }

    fun leave(order: Order) {
        if (spaces[order.spot.toInt() - 1].first == occupied) {
            spaces[order.spot.toInt() - 1] = Pair(null, null)
            println("Spot ${order.spot} is free.")
        } else {
            println("There is no car in spot ${order.spot}.")
        }
    }
}