You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@spark.apache.org by ya...@apache.org on 2020/02/27 14:16:20 UTC
[spark] branch branch-3.0 updated: [SPARK-30956][SQL][TESTS] Use
intercept instead of try-catch to assert failures in IntervalUtilsSuite
This is an automated email from the ASF dual-hosted git repository.
yamamuro pushed a commit to branch branch-3.0
in repository https://gitbox.apache.org/repos/asf/spark.git
The following commit(s) were added to refs/heads/branch-3.0 by this push:
new 933e576 [SPARK-30956][SQL][TESTS] Use intercept instead of try-catch to assert failures in IntervalUtilsSuite
933e576 is described below
commit 933e576aab0a40e53f275ae960fc45b7ed2d6f06
Author: Kent Yao <ya...@hotmail.com>
AuthorDate: Thu Feb 27 23:12:35 2020 +0900
[SPARK-30956][SQL][TESTS] Use intercept instead of try-catch to assert failures in IntervalUtilsSuite
### What changes were proposed in this pull request?
In this PR, I addressed the comment from https://github.com/apache/spark/pull/27672#discussion_r383719562 to use `intercept` instead of `try-catch` block to assert failures in the IntervalUtilsSuite
### Why are the changes needed?
improve tests
### Does this PR introduce any user-facing change?
no
### How was this patch tested?
Nah
Closes #27700 from yaooqinn/intervaltest.
Authored-by: Kent Yao <ya...@hotmail.com>
Signed-off-by: Takeshi Yamamuro <ya...@apache.org>
(cherry picked from commit 2d2706cb86ddccd2fc60378b0f47a437ec354017)
Signed-off-by: Takeshi Yamamuro <ya...@apache.org>
---
.../sql/catalyst/util/IntervalUtilsSuite.scala | 119 +++++----------------
1 file changed, 26 insertions(+), 93 deletions(-)
diff --git a/sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/util/IntervalUtilsSuite.scala b/sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/util/IntervalUtilsSuite.scala
index e7c3163..1628a61 100644
--- a/sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/util/IntervalUtilsSuite.scala
+++ b/sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/util/IntervalUtilsSuite.scala
@@ -35,27 +35,17 @@ class IntervalUtilsSuite extends SparkFunSuite with SQLHelper {
assert(safeStringToInterval(UTF8String.fromString(input)) === expected)
}
- private def checkFromStringWithFunc(
- input: String,
- months: Int,
- days: Int,
- us: Long,
- func: CalendarInterval => CalendarInterval): Unit = {
- val expected = new CalendarInterval(months, days, us)
- assert(func(stringToInterval(UTF8String.fromString(input))) === expected)
- assert(func(safeStringToInterval(UTF8String.fromString(input))) === expected)
+ private def checkFromInvalidString(input: String, errorMsg: String): Unit = {
+ failFuncWithInvalidInput(input, errorMsg, s => stringToInterval(UTF8String.fromString(s)))
+ assert(safeStringToInterval(UTF8String.fromString(input)) === null)
}
- private def checkFromInvalidString(input: String, errorMsg: String): Unit = {
- try {
- stringToInterval(UTF8String.fromString(input))
- fail("Expected to throw an exception for the invalid input")
- } catch {
- case e: IllegalArgumentException =>
- val msg = e.getMessage
- assert(msg.contains(errorMsg))
+ private def failFuncWithInvalidInput(
+ input: String, errorMsg: String, converter: String => CalendarInterval): Unit = {
+ withClue("Expected to throw an exception for the invalid input") {
+ val e = intercept[IllegalArgumentException](converter(input))
+ assert(e.getMessage.contains(errorMsg))
}
- assert(safeStringToInterval(UTF8String.fromString(input)) === null)
}
private def testSingleUnit(
@@ -87,7 +77,6 @@ class IntervalUtilsSuite extends SparkFunSuite with SQLHelper {
}
}
-
test("string to interval: multiple units") {
Seq(
"-1 MONTH 1 day -1 microseconds" -> new CalendarInterval(-1, 1, -1),
@@ -145,22 +134,9 @@ class IntervalUtilsSuite extends SparkFunSuite with SQLHelper {
assert(fromYearMonthString("99-10") === new CalendarInterval(99 * 12 + 10, 0, 0L))
assert(fromYearMonthString("+99-10") === new CalendarInterval(99 * 12 + 10, 0, 0L))
assert(fromYearMonthString("-8-10") === new CalendarInterval(-8 * 12 - 10, 0, 0L))
-
- try {
- fromYearMonthString("99-15")
- fail("Expected to throw an exception for the invalid input")
- } catch {
- case e: IllegalArgumentException =>
- assert(e.getMessage.contains("month 15 outside range"))
- }
-
- try {
- fromYearMonthString("9a9-15")
- fail("Expected to throw an exception for the invalid input")
- } catch {
- case e: IllegalArgumentException =>
- assert(e.getMessage.contains("Interval string does not match year-month format"))
- }
+ failFuncWithInvalidInput("99-15", "month 15 outside range", fromYearMonthString)
+ failFuncWithInvalidInput("9a9-15", "Interval string does not match year-month format",
+ fromYearMonthString)
}
test("from day-time string - legacy") {
@@ -179,29 +155,10 @@ class IntervalUtilsSuite extends SparkFunSuite with SQLHelper {
12 * MICROS_PER_MINUTE + fromMillis(888)))
assert(fromDayTimeString("-3 0:0:0") === new CalendarInterval(0, -3, 0L))
- try {
- fromDayTimeString("5 30:12:20")
- fail("Expected to throw an exception for the invalid input")
- } catch {
- case e: IllegalArgumentException =>
- assert(e.getMessage.contains("hour 30 outside range"))
- }
-
- try {
- fromDayTimeString("5 30-12")
- fail("Expected to throw an exception for the invalid input")
- } catch {
- case e: IllegalArgumentException =>
- assert(e.getMessage.contains("must match day-time format"))
- }
-
- try {
- fromDayTimeString("5 1:12:20", HOUR, MICROSECOND)
- fail("Expected to throw an exception for the invalid convention type")
- } catch {
- case e: IllegalArgumentException =>
- assert(e.getMessage.contains("Cannot support (interval"))
- }
+ failFuncWithInvalidInput("5 30:12:20", "hour 30 outside range", fromDayTimeString)
+ failFuncWithInvalidInput("5 30-12", "must match day-time format", fromDayTimeString)
+ failFuncWithInvalidInput("5 1:12:20", "Cannot support (interval",
+ s => fromDayTimeString(s, HOUR, MICROSECOND))
}
}
@@ -215,13 +172,10 @@ class IntervalUtilsSuite extends SparkFunSuite with SQLHelper {
assert(duration("1 microsecond", TimeUnit.MICROSECONDS, 30) === 1)
assert(duration("1 month -30 days", TimeUnit.DAYS, 31) === 1)
- try {
+ val e = intercept[ArithmeticException] {
duration(Integer.MAX_VALUE + " month", TimeUnit.SECONDS, 31)
- fail("Expected to throw an exception for the invalid input")
- } catch {
- case e: ArithmeticException =>
- assert(e.getMessage.contains("overflow"))
}
+ assert(e.getMessage.contains("overflow"))
}
test("negative interval") {
@@ -283,12 +237,9 @@ class IntervalUtilsSuite extends SparkFunSuite with SQLHelper {
val interval = new CalendarInterval(2, 0, 0)
assert(multiply(interval, Integer.MAX_VALUE) === new CalendarInterval(Int.MaxValue, 0, 0))
- try {
- multiplyExact(interval, Integer.MAX_VALUE)
- fail("Expected to throw an exception on months overflow")
- } catch {
- case e: ArithmeticException => assert(e.getMessage.contains("overflow"))
- }
+
+ val e = intercept[ArithmeticException](multiplyExact(interval, Integer.MAX_VALUE))
+ assert(e.getMessage.contains("overflow"))
}
test("divide by num") {
@@ -307,21 +258,13 @@ class IntervalUtilsSuite extends SparkFunSuite with SQLHelper {
var interval = new CalendarInterval(Int.MaxValue, Int.MaxValue, 0)
assert(divide(interval, 0.9) === new CalendarInterval(Int.MaxValue, Int.MaxValue,
((Int.MaxValue / 9.0) * MICROS_PER_DAY).round))
- try {
- divideExact(interval, 0.9)
- fail("Expected to throw an exception on integer overflow")
- } catch {
- case e: ArithmeticException => assert(e.getMessage.contains("integer overflow"))
- }
+ val e1 = intercept[ArithmeticException](divideExact(interval, 0.9))
+ assert(e1.getMessage.contains("integer overflow"))
interval = new CalendarInterval(123, 456, 789)
assert(divide(interval, 0) === null)
- try {
- divideExact(interval, 0)
- fail("Expected to throw an exception on divide by zero")
- } catch {
- case e: ArithmeticException => assert(e.getMessage.contains("divide by zero"))
- }
+ val e2 = intercept[ArithmeticException](divideExact(interval, 0))
+ assert(e2.getMessage.contains("divide by zero"))
}
test("from day-time string") {
@@ -331,18 +274,8 @@ class IntervalUtilsSuite extends SparkFunSuite with SQLHelper {
assert(fromDayTimeString(input, from, to) === safeStringToInterval(expectedUtf8))
}
}
- def checkFail(
- input: String,
- from: IntervalUnit,
- to: IntervalUnit,
- errMsg: String): Unit = {
- try {
- fromDayTimeString(input, from, to)
- fail("Expected to throw an exception for the invalid input")
- } catch {
- case e: IllegalArgumentException =>
- assert(e.getMessage.contains(errMsg))
- }
+ def checkFail(input: String, from: IntervalUnit, to: IntervalUnit, errMsg: String): Unit = {
+ failFuncWithInvalidInput(input, errMsg, s => fromDayTimeString(s, from, to))
}
check("12:40", HOUR, MINUTE, "12 hours 40 minutes")
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@spark.apache.org
For additional commands, e-mail: commits-help@spark.apache.org