fix scalastyle line length in test comments

Co-authored-by: Isaac

Author: cloud-fan

sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/optimizer/OptimizerSuite.scala

@@ -77,9 +77,9 @@ case class NonDeterministicRuntimeReplaceable(child: Expression)
  * A test-only [[RuntimeReplaceable]] that opts out of eager replacement and whose `replacement`
  * contains a `CURRENT_LIKE` expression ([[CurrentTimestamp]]) but is deterministic, evaluable, and
  * non-foldable (it also reads an input column). Used to check that `ReplaceExpressions` still
- * rewrites it eagerly: the replacement depends on the later `ComputeCurrentTime` rule, which matches
- * the `CURRENT_LIKE` tree pattern that a survivor would hide, so the `eagerReplace = false` opt-out
- * must be overridden.
+ * rewrites it eagerly: the replacement depends on the later `ComputeCurrentTime` rule, which
+ * matches the `CURRENT_LIKE` tree pattern that a survivor would hide, so the `eagerReplace = false`
+ * opt-out must be overridden.
  */
 case class CurrentTimeRuntimeReplaceable(child: Expression)
   extends RuntimeReplaceable with UnaryLike[Expression] {
@@ -467,13 +467,13 @@ class OptimizerSuite extends PlanTest {
 
     // The replacement contains `CurrentTimestamp` (a CURRENT_LIKE node) but is deterministic,
     // evaluable, and non-foldable (it reads an input column), so it would otherwise survive
-    // `ReplaceExpressions`. A survivor exposes only the RUNTIME_REPLACEABLE pattern of its children,
-    // not the CURRENT_LIKE pattern of its hidden replacement, so `ComputeCurrentTime` (which runs
-    // right after and prunes on CURRENT_LIKE) could not reach the `CurrentTimestamp` to fold it into
-    // a single query-start literal -- leaving it to be evaluated per row at execution and yielding
-    // different values within one query. The gate forces eager replacement, exposing CURRENT_LIKE so
-    // it is folded here. The child is an attribute (not a literal) so constant folding cannot mask
-    // the problem.
+    // `ReplaceExpressions`. A survivor exposes only the RUNTIME_REPLACEABLE pattern of its
+    // children, not the CURRENT_LIKE pattern of its hidden replacement, so `ComputeCurrentTime`
+    // (which runs right after and prunes on CURRENT_LIKE) could not reach the `CurrentTimestamp`
+    // to fold it into a single query-start literal -- leaving it to be evaluated per row at
+    // execution and yielding different values within one query. The gate forces eager
+    // replacement, exposing CURRENT_LIKE so it is folded here. The child is an attribute (not a
+    // literal) so constant folding cannot mask the problem.
     assert(!optimized.expressions.exists(_.exists(_.isInstanceOf[RuntimeReplaceable])),
       s"Expected the CURRENT_LIKE RuntimeReplaceable to be rewritten eagerly:\n$optimized")
     assert(!optimized.expressions.exists(_.exists(_.isInstanceOf[CurrentTimestamp])),

sql/core/src/test/scala/org/apache/spark/sql/execution/MaterializeRuntimeReplaceableSuite.scala

@@ -242,9 +242,9 @@ class MaterializeRuntimeReplaceableSuite extends QueryTest with SharedSparkSessi
 
   test("SPARK-57512: a surviving equi-join predicate RuntimeReplaceable is extracted as a " +
       "join key") {
-    // Disable broadcast so the only equi-join plan is a sort-merge join; without key extraction the
-    // join degrades to a `CartesianProductExec`. Disable AQE so the join operator is directly on the
-    // executed plan rather than inside an `AdaptiveSparkPlanExec` subtree.
+    // Disable broadcast so the only equi-join plan is a sort-merge join; without key extraction
+    // the join degrades to a `CartesianProductExec`. Disable AQE so the join operator is directly
+    // on the executed plan rather than inside an `AdaptiveSparkPlanExec` subtree.
     withSQLConf(
         SQLConf.AUTO_BROADCASTJOIN_THRESHOLD.key -> "-1",
         SQLConf.ADAPTIVE_EXECUTION_ENABLED.key -> "false") {
@@ -260,8 +260,8 @@ class MaterializeRuntimeReplaceableSuite extends QueryTest with SharedSparkSessi
           optimized.expressions.exists(_.exists(_.isInstanceOf[RuntimeReplaceable])),
           s"Expected a surviving RuntimeReplaceable join condition:\n$optimized")
 
-        // `ExtractEquiJoinKeys` unfolds the survivor and extracts the join key, so a sort-merge join
-        // is planned. Without the unfold the equality is invisible and the join degrades to a
+        // `ExtractEquiJoinKeys` unfolds the survivor and extracts the join key, so a sort-merge
+        // join is planned. Without the unfold the equality is invisible and the join degrades to a
         // Cartesian product (the same gap fails stream-stream join analysis with "without equality
         // predicate", since `StreamingJoinStrategy` shares this extractor).
         val executed = df.queryExecution.executedPlan