Update test name

Author: takapi327

modules/mysql/shared/src/test/scala/ldbc/mysql/ReadTimeoutClosesConnectionTest.scala

@@ -45,7 +45,7 @@ class ReadTimeoutClosesConnectionTest extends FTestPlatform:
           second <- conn.createStatement().flatMap(_.executeQuery("SELECT 1")).attempt
         yield second.left.exists(_.getMessage.contains("transport has failed"))
       },
-      "故障後の文が fail-fast していない"
+      "a statement on a failed transport did not fail fast"
     )
 
   test("a healthy connection is not marked closed"):

modules/mysql/shared/src/test/scala/ldbc/mysql/TransportFailureSilenceTest.scala

@@ -108,7 +108,7 @@ class TransportFailureSilenceTest extends FTestPlatform:
       closed     <- connection.isClosed()
     yield (written.size, closed)
 
-    assertFx(program, (0, true), "故障した接続の close() がネットワークに書き込んでいる")
+    assertFx(program, (0, true), "close() on a failed connection still wrote to the network")
 
   test("StreamingResultSet.next() on a failed transport writes nothing"):
     val program = for
@@ -118,7 +118,7 @@ class TransportFailureSilenceTest extends FTestPlatform:
       written   <- pair._2.get
     yield (outcome.left.exists(_.isInstanceOf[SQLTransientConnectionException]), written.size)
 
-    assertFx(program, (true, 0), "故障後の next() が COM_STMT_FETCH を送っている")
+    assertFx(program, (true, 0), "next() after a failure still sent COM_STMT_FETCH")
 
   test("a healthy StreamingResultSet still fetches"):
     val program = for
@@ -128,4 +128,4 @@ class TransportFailureSilenceTest extends FTestPlatform:
       written   <- pair._2.get
     yield written.size
 
-    assertFxBoolean(program.map(_ > 0), "健全な接続で next() が一度もソケットに書いていない")
+    assertFxBoolean(program.map(_ > 0), "next() on a healthy connection never wrote to the socket")

modules/mysql/shared/src/test/scala/ldbc/mysql/net/BitVectorSocketEofTest.scala

@@ -42,15 +42,15 @@ class BitVectorSocketEofTest extends FTestPlatform:
       outcome <- socket.read(4).attempt
     yield outcome.left.map(_.getClass.getSimpleName).left.getOrElse("succeeded unexpectedly")
 
-    assertFx(program, "EofException", "EOF がタイムアウトとして報告されている")
+    assertFx(program, "EofException", "end of stream is still reported as a timeout")
 
   test("EofException reports how many bytes were requested and how many arrived"):
     val program = for
       socket  <- socketOver(List(Array[Byte](1, 2, 3)))
       outcome <- socket.read(8).attempt
     yield outcome.left.toOption.collect { case eof: EofException => (eof.bytesRequested, eof.bytesRead) }
 
-    assertFx(program, Some((8, 3)), "EofException が要求バイト数と既読バイト数を正しく持っていない")
+    assertFx(program, Some((8, 3)), "EofException does not carry the expected and received byte counts")
 
   test("end of stream is not reported as SQLTimeoutException"):
     val program = for

modules/mysql/shared/src/test/scala/ldbc/mysql/net/TransportFailureTest.scala

@@ -94,7 +94,7 @@ class TransportFailureTest extends FTestPlatform:
       failed <- pair._2.get
     yield failed
 
-    assertFx(program, true, "PacketTooBigException が故障として記録されていない")
+    assertFx(program, true, "PacketTooBigException was not recorded as a transport failure")
 
   test("a payload the decoder rejects marks the transport as failed"):
     val garbage = ByteVector(Array[Byte](0x7f, 0x01, 0x02)).toBitVector
@@ -105,7 +105,7 @@ class TransportFailureTest extends FTestPlatform:
       failed <- pair._2.get
     yield failed
 
-    assertFx(program, true, "デコード失敗が故障として記録されていない")
+    assertFx(program, true, "a decode failure was not recorded as a transport failure")
 
   test("cancelling a receive marks the transport as failed"):
     val program = for
@@ -117,7 +117,7 @@ class TransportFailureTest extends FTestPlatform:
       failed  <- pair._2.get
     yield failed
 
-    assertFx(program, true, "キャンセルされた receive が故障として記録されていない")
+    assertFx(program, true, "a cancelled receive was not recorded as a transport failure")
 
   test("a packet that decodes cleanly leaves the transport usable"):
     val program = for
@@ -127,7 +127,7 @@ class TransportFailureTest extends FTestPlatform:
       failed   <- pair._2.get
     yield (received.isInstanceOf[OKPacket], failed)
 
-    assertFx(program, (true, false), "正常にデコードできたのに故障として記録されている")
+    assertFx(program, (true, false), "a successfully decoded packet was recorded as a transport failure")
 
   test("a successful send leaves the transport usable"):
     val program = for

modules/net/js/src/test/scala/ldbc/net/NodeReadCancellationTest.scala

@@ -60,7 +60,7 @@ class NodeReadCancellationTest extends munit.FunSuite:
       firstCalled = Promise[String]()
       canceler    = raw.read(4, r => { if !firstCalled.isCompleted then firstCalled.success(s"called: $r"); () })
       _ <- delay(200)
-      _ = assert(!firstCalled.isCompleted, "データが無いのに1回目の read が完了している")
+      _ = assert(!firstCalled.isCompleted, "the first read completed even though no data had arrived")
 
       _ = canceler.cancel()
       _ <- delay(100)
@@ -82,5 +82,5 @@ class NodeReadCancellationTest extends munit.FunSuite:
     yield
       raw.close()
       server.close()
-      assertEquals(got, "AAAABBBB", s"キャンセルした read がバイトを捨てている（読めたのは '$got'）")
+      assertEquals(got, "AAAABBBB", s"a cancelled read discarded bytes (only '$got' was left)")
   }

modules/net/jvm-native/src/test/scala/ldbc/net/RawSocketCancellationTest.scala

@@ -31,15 +31,15 @@ class RawSocketCancellationTest extends munit.FunSuite:
     var waited = 0
     while accepted.get() == null && waited < 10000 do { Thread.sleep(25); waited += 25 }
     val socket = accepted.get()
-    assert(socket != null, "サーバが accept できなかった")
+    assert(socket != null, "the server never accepted a connection")
     socket
 
   private def connectRaw(port: Int): RawSocket =
     val ref   = new AtomicReference[Either[Throwable, RawSocket]](null)
     val latch = new CountDownLatch(1)
     engine.connect("127.0.0.1", port, SocketOptions.default, r => { ref.set(r); latch.countDown() })
-    assert(latch.await(10, TimeUnit.SECONDS), "connect がタイムアウトした")
-    ref.get().fold(e => fail(s"connect 失敗: $e"), identity)
+    assert(latch.await(10, TimeUnit.SECONDS), "connect timed out")
+    ref.get().fold(e => fail(s"connect failed: $e"), identity)
 
   test("cancelling a read leaves the bytes for the next read"):
     val (port, accepted) = acceptOne()
@@ -49,7 +49,7 @@ class RawSocketCancellationTest extends munit.FunSuite:
     val firstCallback = new AtomicReference[String]("not called")
     val canceler      = client.read(4, r => firstCallback.set(s"called: $r"))
     Thread.sleep(300)
-    assertEquals(firstCallback.get(), "not called", "データが無いのに1回目の read が完了している")
+    assertEquals(firstCallback.get(), "not called", "the first read completed even though no data had arrived")
 
     canceler.cancel()
     Thread.sleep(300)
@@ -71,7 +71,7 @@ class RawSocketCancellationTest extends munit.FunSuite:
     val got = if secondLatch.await(5, TimeUnit.SECONDS) then secondRef.get() else "timed out"
     client.close()
 
-    assertEquals(got, "AAAABBBB", s"キャンセルした read がバイトを消費して捨てている（読めたのは '$got'）")
+    assertEquals(got, "AAAABBBB", s"a cancelled read consumed and discarded bytes (only '$got' was left)")
 
   test("cancelling a write still transfers every byte"):
     val (port, accepted) = acceptOne()
@@ -85,7 +85,7 @@ class RawSocketCancellationTest extends munit.FunSuite:
     val canceler  = client.write(payload, _ => writeDone.set(true))
 
     Thread.sleep(500)
-    assert(!writeDone.get(), "ペイロードが小さすぎて部分書き込みが起きていない（テストの前提が崩れている）")
+    assert(!writeDone.get(), "the payload was too small to force a partial write, so this test proves nothing")
 
     canceler.cancel()
 
@@ -109,5 +109,5 @@ class RawSocketCancellationTest extends munit.FunSuite:
     assertEquals(
       received.get(),
       size,
-      s"キャンセルされた write が途中で打ち切られている（${ received.get() } / $size バイトしか届いていない）"
+      s"a cancelled write stopped midway (${ received.get() } of $size bytes arrived)"
     )

modules/net/jvm/src/test/scala/ldbc/net/SocketOptionsTest.scala

@@ -36,8 +36,8 @@ class SocketOptionsTest extends munit.FunSuite:
     applied(SocketOptions(sendBufferSize = Some(requested), receiveBufferSize = Some(requested))): ch =>
       val send = ch.getOption(StandardSocketOptions.SO_SNDBUF).intValue
       val recv = ch.getOption(StandardSocketOptions.SO_RCVBUF).intValue
-      assert(send > default._1, s"sendBufferSize がソケットに届いていない（既定 ${ default._1 } / 指定後 $send）")
-      assert(recv > default._2, s"receiveBufferSize がソケットに届いていない（既定 ${ default._2 } / 指定後 $recv）")
+      assert(send > default._1, s"sendBufferSize never reached the socket (default ${ default._1 }, applied $send)")
+      assert(recv > default._2, s"receiveBufferSize never reached the socket (default ${ default._2 }, applied $recv)")
 
   test("leaving the buffer sizes unset keeps the platform defaults"):
     val untouched = SocketChannel.open()

modules/pool/shared/src/test/scala/ldbc/pool/DeadConnectionEvictionTest.scala

@@ -37,9 +37,9 @@ class DeadConnectionEvictionTest extends FxSuite:
                 }
       validations <- mock.validationCount.get
     yield
-      assertEquals(status.idle, 0, "死亡した接続がアイドルとしてプールに戻っている")
-      assertEquals(status.total, 0, "死亡した接続がプールから除去されていない")
-      assertEquals(validations, 0, "バイパス窓の中なのに検証の往復が走っている（バイパスが効いていない）")
+      assertEquals(status.idle, 0, "a dead connection went back into the pool as idle")
+      assertEquals(status.total, 0, "a dead connection was not removed from the pool")
+      assertEquals(validations, 0, "a validation round trip ran inside the bypass window, so the bypass is not working")
   }
 
   test("a connection that died while idle is evicted on lease, even inside aliveBypassWindow") {
@@ -57,8 +57,8 @@ class DeadConnectionEvictionTest extends FxSuite:
                          }
       total <- created.get.map(_.size)
     yield
-      assertEquals(leasedWasClosed, false, "死亡した接続がリース時に除去されず、そのまま払い出されている")
-      assert(total >= 2, s"死亡した接続を捨てたあと代替が生成されていない（生成数: $total）")
+      assertEquals(leasedWasClosed, false, "a dead connection was handed out instead of being evicted on lease")
+      assert(total >= 2, s"no replacement was created after discarding the dead connection ($total created)")
   }
 
   test("a healthy connection is still pooled inside aliveBypassWindow") {
@@ -69,9 +69,9 @@ class DeadConnectionEvictionTest extends FxSuite:
                 }
       validations <- mock.validationCount.get
     yield
-      assertEquals(status.idle, 1, "健全な接続が不必要に除去されている")
+      assertEquals(status.idle, 1, "a healthy connection was evicted for no reason")
       assertEquals(status.total, 1)
-      assertEquals(validations, 1, "テスト自身の isValid 以外に検証の往復が走っている")
+      assertEquals(validations, 1, "a validation round trip ran beyond the isValid this test performs itself")
   }
 
   test("with the bypass disabled the validation round trip does run") {
@@ -82,5 +82,5 @@ class DeadConnectionEvictionTest extends FxSuite:
              datasource.use(_ => Fx.unit) >> datasource.status
            }
       validations <- mock.validationCount.get
-    yield assert(validations > 0, "aliveBypassWindow = 0 でも検証の往復が走っていない")
+    yield assert(validations > 0, "no validation round trip ran even with aliveBypassWindow = 0")
   }