From d5532702b108fc9f2b4ae80b926fca4167a8655e Mon Sep 17 00:00:00 2001 From: Roman Lukash Date: Fri, 30 Aug 2024 10:11:04 +0200 Subject: [PATCH 1/9] Add color diff for small dataframe comparison --- .../spark/fast/tests/DataFrameComparer.scala | 29 +++--- .../spark/fast/tests/DataframeUtil.scala | 92 +++++++++++++++++++ 2 files changed, 110 insertions(+), 11 deletions(-) create mode 100644 src/main/scala/com/github/mrpowers/spark/fast/tests/DataframeUtil.scala diff --git a/src/main/scala/com/github/mrpowers/spark/fast/tests/DataFrameComparer.scala b/src/main/scala/com/github/mrpowers/spark/fast/tests/DataFrameComparer.scala index e47e0bc..1bf4ede 100644 --- a/src/main/scala/com/github/mrpowers/spark/fast/tests/DataFrameComparer.scala +++ b/src/main/scala/com/github/mrpowers/spark/fast/tests/DataFrameComparer.scala @@ -1,7 +1,7 @@ package com.github.mrpowers.spark.fast.tests +import com.github.mrpowers.spark.fast.tests.SeqLikesExtensions.SeqExtensions import org.apache.spark.sql.{DataFrame, Row} - trait DataFrameComparer extends DatasetComparer { /** @@ -14,17 +14,24 @@ trait DataFrameComparer extends DatasetComparer { ignoreColumnNames: Boolean = false, orderedComparison: Boolean = true, ignoreColumnOrder: Boolean = false, - truncate: Int = 500 + truncate: Int = 500, ): Unit = { - assertSmallDatasetEquality( - actualDF, - expectedDF, - ignoreNullable, - ignoreColumnNames, - orderedComparison, - ignoreColumnOrder, - truncate - ) + SchemaComparer.assertSchemaEqual(actualDF, expectedDF, ignoreNullable, ignoreColumnNames, ignoreColumnOrder) + val actual = if (ignoreColumnOrder) orderColumns(actualDF, expectedDF) else actualDF + if (orderedComparison) + assertSmallDataFrameEquality(actual, expectedDF, truncate) + else + assertSmallDataFrameEquality(defaultSortDataset(actual), defaultSortDataset(expectedDF), truncate) + } + + def assertSmallDataFrameEquality(actualDF: DataFrame, expectedDF: DataFrame, truncate: Int): Unit = { + val a = actualDF.collect() + val e = expectedDF.collect() + if (!a.toSeq.approximateSameElements(e, (o1: Row, o2: Row) => o1.equals(o2))) { + val arr = ("Actual Content", "Expected Content") + val msg = "Diffs\n" ++ DataframeUtil.showDataframeDiff(arr, a, e, truncate) + throw DatasetContentMismatch(msg) + } } /** diff --git a/src/main/scala/com/github/mrpowers/spark/fast/tests/DataframeUtil.scala b/src/main/scala/com/github/mrpowers/spark/fast/tests/DataframeUtil.scala new file mode 100644 index 0000000..7bc8d21 --- /dev/null +++ b/src/main/scala/com/github/mrpowers/spark/fast/tests/DataframeUtil.scala @@ -0,0 +1,92 @@ +package com.github.mrpowers.spark.fast.tests + +import com.github.mrpowers.spark.fast.tests.ufansi.Color.{DarkGray, Green, Red} +import org.apache.commons.lang3.StringUtils +import org.apache.spark.sql.Row + +object DataframeUtil { + + def showDataframeDiff( + header: (String, String), + actual: Array[Row], + expected: Array[Row], + truncate: Int = 20 + ): String = { + + val sb = new StringBuilder + val diff = actual.zip(expected).map { case (a, e) => + if (equals(a, e)) { + List(ufansi.Color.DarkGray(a.toString()), ufansi.Color.DarkGray(e.toString())) + } else { + val d = a.toSeq + .zip(e.toSeq) + .map { case (a1, e1) => + if (a1 == e1) + (DarkGray(a1.toString()), DarkGray(e1.toString)) + else (Red(a1.toString()), Green(e1.toString)) + } + List( + DarkGray("[") ++ d.map(_._1).reduce(_ ++ DarkGray(",") ++ _) ++ DarkGray("]"), + DarkGray("[") ++ d.map(_._2).reduce(_ ++ DarkGray(",") ++ _) ++ DarkGray("]") + ) + } + } + val rows = Array(List(header._1, header._2)) + val numCols = 2 + + // Initialise the width of each column to a minimum value of '3' + val colWidths = Array.fill(numCols)(3) + + // Compute the width of each column + for (row <- rows) { + for ((cell, i) <- row.zipWithIndex) { + colWidths(i) = math.max(colWidths(i), cell.length) + } + } + for (row <- diff) { + for ((cell, i) <- row.zipWithIndex) { + colWidths(i) = math.max(colWidths(i), cell.length) + } + } + + // Create SeparateLine + val sep: String = + colWidths + .map("-" * _) + .addString(sb, "+", "+", "+\n") + .toString() + + // column names + val h: Seq[(String, Int)] = rows.head.zipWithIndex + h.map { case (cell, i) => + if (truncate > 0) { + StringUtils.leftPad(cell, colWidths(i)) + } else { + StringUtils.rightPad(cell, colWidths(i)) + } + }.addString(sb, "|", "|", "|\n") + + sb.append(sep) + + diff.map { row => + row.zipWithIndex + .map { case (cell, i) => + val padsLen = colWidths(i) - cell.length + val pads = if (padsLen > 0) " " * padsLen else "" + if (truncate > 0) { + pads + cell.toString + } else { + cell.toString + pads + } + + } + .addString(sb, "|", "|", "|\n") + } + + sb.append(sep) + + sb.toString() + } + + +} From 98acde976c10af5d77a1b4afc648466327bb64f9 Mon Sep 17 00:00:00 2001 From: happytomatoe <2893931+happytomatoe@users.noreply.github.com> Date: Fri, 30 Aug 2024 18:59:19 +0200 Subject: [PATCH 2/9] Fix tests --- .../spark/fast/tests/DataframeUtil.scala | 59 +++++++++++++------ 1 file changed, 41 insertions(+), 18 deletions(-) diff --git a/src/main/scala/com/github/mrpowers/spark/fast/tests/DataframeUtil.scala b/src/main/scala/com/github/mrpowers/spark/fast/tests/DataframeUtil.scala index 7bc8d21..c1e5829 100644 --- a/src/main/scala/com/github/mrpowers/spark/fast/tests/DataframeUtil.scala +++ b/src/main/scala/com/github/mrpowers/spark/fast/tests/DataframeUtil.scala @@ -1,37 +1,61 @@ package com.github.mrpowers.spark.fast.tests import com.github.mrpowers.spark.fast.tests.ufansi.Color.{DarkGray, Green, Red} +import com.github.mrpowers.spark.fast.tests.ufansi.Str import org.apache.commons.lang3.StringUtils import org.apache.spark.sql.Row object DataframeUtil { def showDataframeDiff( - header: (String, String), - actual: Array[Row], - expected: Array[Row], - truncate: Int = 20 - ): String = { + header: (String, String), + actual: Array[Row], + expected: Array[Row], + truncate: Int = 20 + ): String = { val sb = new StringBuilder - val diff = actual.zip(expected).map { case (a, e) => + + val a = actual.zipAll(expected, Row(), Row()) + val diff = a.map { case (a, e) => if (equals(a, e)) { List(ufansi.Color.DarkGray(a.toString()), ufansi.Color.DarkGray(e.toString())) } else { - val d = a.toSeq - .zip(e.toSeq) - .map { case (a1, e1) => - if (a1 == e1) - (DarkGray(a1.toString()), DarkGray(e1.toString)) - else (Red(a1.toString()), Green(e1.toString)) + val actual = a.toSeq + val expected = e.toSeq + if (actual.isEmpty) + List( + Red("[]"), + Green(expected.mkString("[", ",", "]")) + ) + else if (expected.isEmpty) + List(Red(actual.mkString("[", ",", "]")), Green("[]")) + else { + val withEquals = actual + .zip(expected) + .map { case (a1, e1) => (a1, e1, a1 == e1) } + val allFieldsAreNotEqual = !withEquals.exists(_._3) + if (allFieldsAreNotEqual) { + List( + Red(actual.mkString("[", ",", "]")), + Green(expected.mkString("[", ",", "]")) + ) + } else { + val d = withEquals + .map { case (a1, e1, equal) => + if (equal) + (DarkGray(a1.toString()), DarkGray(e1.toString)) + else (Red(a1.toString()), Green(e1.toString)) + } + List( + DarkGray("[") ++ d.map(_._1).reduce(_ ++ DarkGray(",") ++ _) ++ DarkGray("]"), + DarkGray("[") ++ d.map(_._2).reduce(_ ++ DarkGray(",") ++ _) ++ DarkGray("]") + ) } - List( - DarkGray("[") ++ d.map(_._1).reduce(_ ++ DarkGray(",") ++ _) ++ DarkGray("]"), - DarkGray("[") ++ d.map(_._2).reduce(_ ++ DarkGray(",") ++ _) ++ DarkGray("]") - ) + } } } - val rows = Array(List(header._1, header._2)) + val rows = Array(List(header._1, header._2)) val numCols = 2 // Initialise the width of each column to a minimum value of '3' @@ -88,5 +112,4 @@ object DataframeUtil { sb.toString() } - } From 19468e6a918ff843b6494738fa0d77dbea535709 Mon Sep 17 00:00:00 2001 From: happytomatoe <2893931+happytomatoe@users.noreply.github.com> Date: Sat, 31 Aug 2024 10:24:13 +0200 Subject: [PATCH 3/9] Changes after review --- .../spark/fast/tests/DataframeUtil.scala | 68 +++++++++---------- 1 file changed, 34 insertions(+), 34 deletions(-) diff --git a/src/main/scala/com/github/mrpowers/spark/fast/tests/DataframeUtil.scala b/src/main/scala/com/github/mrpowers/spark/fast/tests/DataframeUtil.scala index c1e5829..7872ab3 100644 --- a/src/main/scala/com/github/mrpowers/spark/fast/tests/DataframeUtil.scala +++ b/src/main/scala/com/github/mrpowers/spark/fast/tests/DataframeUtil.scala @@ -11,41 +11,42 @@ object DataframeUtil { header: (String, String), actual: Array[Row], expected: Array[Row], - truncate: Int = 20 + truncate: Int = 20, + minColWidth: Int = 3 ): String = { val sb = new StringBuilder - val a = actual.zipAll(expected, Row(), Row()) - val diff = a.map { case (a, e) => - if (equals(a, e)) { - List(ufansi.Color.DarkGray(a.toString()), ufansi.Color.DarkGray(e.toString())) + val fullJoin = actual.zipAll(expected, Row(), Row()) + val diff = fullJoin.map { case (actualRow, expectedRow) => + if (equals(actualRow, expectedRow)) { + List(DarkGray(actualRow.toString), DarkGray(expectedRow.toString)) } else { - val actual = a.toSeq - val expected = e.toSeq - if (actual.isEmpty) + val actualSeq = actualRow.toSeq + val expectedSeq = expectedRow.toSeq + if (actualSeq.isEmpty) List( Red("[]"), - Green(expected.mkString("[", ",", "]")) + Green(expectedSeq.mkString("[", ",", "]")) ) - else if (expected.isEmpty) - List(Red(actual.mkString("[", ",", "]")), Green("[]")) + else if (expectedSeq.isEmpty) + List(Red(actualSeq.mkString("[", ",", "]")), Green("[]")) else { - val withEquals = actual - .zip(expected) + val withEquals = actualSeq + .zip(expectedSeq) .map { case (a1, e1) => (a1, e1, a1 == e1) } val allFieldsAreNotEqual = !withEquals.exists(_._3) if (allFieldsAreNotEqual) { List( - Red(actual.mkString("[", ",", "]")), - Green(expected.mkString("[", ",", "]")) + Red(actualSeq.mkString("[", ",", "]")), + Green(expectedSeq.mkString("[", ",", "]")) ) } else { val d = withEquals .map { case (a1, e1, equal) => if (equal) - (DarkGray(a1.toString()), DarkGray(e1.toString)) - else (Red(a1.toString()), Green(e1.toString)) + (DarkGray(a1.toString), DarkGray(e1.toString)) + else (Red(a1.toString), Green(e1.toString)) } List( DarkGray("[") ++ d.map(_._1).reduce(_ ++ DarkGray(",") ++ _) ++ DarkGray("]"), @@ -55,17 +56,15 @@ object DataframeUtil { } } } - val rows = Array(List(header._1, header._2)) - val numCols = 2 + val headerSeq = List(header._1, header._2) + val numCols = 2 - // Initialise the width of each column to a minimum value of '3' - val colWidths = Array.fill(numCols)(3) + // Initialise the width of each column to a minimum value + val colWidths = Array.fill(numCols)(minColWidth) // Compute the width of each column - for (row <- rows) { - for ((cell, i) <- row.zipWithIndex) { - colWidths(i) = math.max(colWidths(i), cell.length) - } + for ((cell, i) <- headerSeq.zipWithIndex) { + colWidths(i) = math.max(colWidths(i), cell.length) } for (row <- diff) { for ((cell, i) <- row.zipWithIndex) { @@ -78,17 +77,18 @@ object DataframeUtil { colWidths .map("-" * _) .addString(sb, "+", "+", "+\n") - .toString() + .toString // column names - val h: Seq[(String, Int)] = rows.head.zipWithIndex - h.map { case (cell, i) => - if (truncate > 0) { - StringUtils.leftPad(cell, colWidths(i)) - } else { - StringUtils.rightPad(cell, colWidths(i)) + headerSeq.zipWithIndex + .map { case (cell, i) => + if (truncate > 0) { + StringUtils.leftPad(cell, colWidths(i)) + } else { + StringUtils.rightPad(cell, colWidths(i)) + } } - }.addString(sb, "|", "|", "|\n") + .addString(sb, "|", "|", "|\n") sb.append(sep) @@ -109,7 +109,7 @@ object DataframeUtil { sb.append(sep) - sb.toString() + sb.toString } } From fe6a624e18f23d1f5cee8842456c5c4cf478a11c Mon Sep 17 00:00:00 2001 From: happytomatoe <2893931+happytomatoe@users.noreply.github.com> Date: Sat, 31 Aug 2024 10:27:45 +0200 Subject: [PATCH 4/9] Refactor --- .../mrpowers/spark/fast/tests/DataframeUtil.scala | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/src/main/scala/com/github/mrpowers/spark/fast/tests/DataframeUtil.scala b/src/main/scala/com/github/mrpowers/spark/fast/tests/DataframeUtil.scala index 7872ab3..e9ff0d2 100644 --- a/src/main/scala/com/github/mrpowers/spark/fast/tests/DataframeUtil.scala +++ b/src/main/scala/com/github/mrpowers/spark/fast/tests/DataframeUtil.scala @@ -34,7 +34,7 @@ object DataframeUtil { else { val withEquals = actualSeq .zip(expectedSeq) - .map { case (a1, e1) => (a1, e1, a1 == e1) } + .map { case (actualRowField, expectedRowField) => (actualRowField, expectedRowField, actualRowField == expectedRowField) } val allFieldsAreNotEqual = !withEquals.exists(_._3) if (allFieldsAreNotEqual) { List( @@ -42,15 +42,15 @@ object DataframeUtil { Green(expectedSeq.mkString("[", ",", "]")) ) } else { - val d = withEquals - .map { case (a1, e1, equal) => + val coloredDiff = withEquals + .map { case (actualRowField, expectedRowField, equal) => if (equal) - (DarkGray(a1.toString), DarkGray(e1.toString)) - else (Red(a1.toString), Green(e1.toString)) + (DarkGray(actualRowField.toString), DarkGray(expectedRowField.toString)) + else (Red(actualRowField.toString), Green(expectedRowField.toString)) } List( - DarkGray("[") ++ d.map(_._1).reduce(_ ++ DarkGray(",") ++ _) ++ DarkGray("]"), - DarkGray("[") ++ d.map(_._2).reduce(_ ++ DarkGray(",") ++ _) ++ DarkGray("]") + DarkGray("[") ++ coloredDiff.map(_._1).reduce(_ ++ DarkGray(",") ++ _) ++ DarkGray("]"), + DarkGray("[") ++ coloredDiff.map(_._2).reduce(_ ++ DarkGray(",") ++ _) ++ DarkGray("]") ) } } From 78125df4bce2478fca185d9fcc761852c18e572d Mon Sep 17 00:00:00 2001 From: happytomatoe <2893931+happytomatoe@users.noreply.github.com> Date: Sat, 31 Aug 2024 11:16:34 +0200 Subject: [PATCH 5/9] Refactor --- .../mrpowers/spark/fast/tests/DataframeUtil.scala | 11 +++++++---- .../spark/fast/tests/ufansi/FansiExtensions.scala | 7 +++++++ 2 files changed, 14 insertions(+), 4 deletions(-) create mode 100644 src/main/scala/com/github/mrpowers/spark/fast/tests/ufansi/FansiExtensions.scala diff --git a/src/main/scala/com/github/mrpowers/spark/fast/tests/DataframeUtil.scala b/src/main/scala/com/github/mrpowers/spark/fast/tests/DataframeUtil.scala index e9ff0d2..1f3f6dc 100644 --- a/src/main/scala/com/github/mrpowers/spark/fast/tests/DataframeUtil.scala +++ b/src/main/scala/com/github/mrpowers/spark/fast/tests/DataframeUtil.scala @@ -1,10 +1,9 @@ package com.github.mrpowers.spark.fast.tests import com.github.mrpowers.spark.fast.tests.ufansi.Color.{DarkGray, Green, Red} -import com.github.mrpowers.spark.fast.tests.ufansi.Str import org.apache.commons.lang3.StringUtils import org.apache.spark.sql.Row - +import com.github.mrpowers.spark.fast.tests.ufansi.FansiExtensions.StrOps object DataframeUtil { def showDataframeDiff( @@ -42,15 +41,19 @@ object DataframeUtil { Green(expectedSeq.mkString("[", ",", "]")) ) } else { + val coloredDiff = withEquals .map { case (actualRowField, expectedRowField, equal) => if (equal) (DarkGray(actualRowField.toString), DarkGray(expectedRowField.toString)) else (Red(actualRowField.toString), Green(expectedRowField.toString)) } + val start = DarkGray("[") + val sep = DarkGray(",") + val end = DarkGray("]") List( - DarkGray("[") ++ coloredDiff.map(_._1).reduce(_ ++ DarkGray(",") ++ _) ++ DarkGray("]"), - DarkGray("[") ++ coloredDiff.map(_._2).reduce(_ ++ DarkGray(",") ++ _) ++ DarkGray("]") + coloredDiff.map(_._1).mkStr(start, sep, end), + coloredDiff.map(_._2).mkStr(start, sep, end) ) } } diff --git a/src/main/scala/com/github/mrpowers/spark/fast/tests/ufansi/FansiExtensions.scala b/src/main/scala/com/github/mrpowers/spark/fast/tests/ufansi/FansiExtensions.scala new file mode 100644 index 0000000..828dace --- /dev/null +++ b/src/main/scala/com/github/mrpowers/spark/fast/tests/ufansi/FansiExtensions.scala @@ -0,0 +1,7 @@ +package com.github.mrpowers.spark.fast.tests.ufansi +object FansiExtensions { + implicit class StrOps(c: Seq[Str]) { + def mkStr(start: Str, sep: Str, end: Str): Str = + start ++ c.reduce(_ ++ sep ++ _) ++ end + } +} \ No newline at end of file From f42d3b3a31feca8642bac513109a713fff65f992 Mon Sep 17 00:00:00 2001 From: happytomatoe <2893931+happytomatoe@users.noreply.github.com> Date: Sat, 31 Aug 2024 12:18:53 +0200 Subject: [PATCH 6/9] WIP --- .../mrpowers/spark/fast/tests/ufansi/FansiExtensions.scala | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/main/scala/com/github/mrpowers/spark/fast/tests/ufansi/FansiExtensions.scala b/src/main/scala/com/github/mrpowers/spark/fast/tests/ufansi/FansiExtensions.scala index 828dace..9c74315 100644 --- a/src/main/scala/com/github/mrpowers/spark/fast/tests/ufansi/FansiExtensions.scala +++ b/src/main/scala/com/github/mrpowers/spark/fast/tests/ufansi/FansiExtensions.scala @@ -2,6 +2,9 @@ package com.github.mrpowers.spark.fast.tests.ufansi object FansiExtensions { implicit class StrOps(c: Seq[Str]) { def mkStr(start: Str, sep: Str, end: Str): Str = - start ++ c.reduce(_ ++ sep ++ _) ++ end + c.foldLeft(start)((leftAcc: Str, e: Str) => { + val separator = if (leftAcc == start) Str("") else sep + leftAcc ++ separator ++ e + }) ++ end } } \ No newline at end of file From 267f9ab38dbcef9e0ce050032ba76fd876a739ac Mon Sep 17 00:00:00 2001 From: happytomatoe <2893931+happytomatoe@users.noreply.github.com> Date: Sun, 1 Sep 2024 07:51:33 +0200 Subject: [PATCH 7/9] Change mkStr to use reduce --- .../mrpowers/spark/fast/tests/ufansi/FansiExtensions.scala | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/src/main/scala/com/github/mrpowers/spark/fast/tests/ufansi/FansiExtensions.scala b/src/main/scala/com/github/mrpowers/spark/fast/tests/ufansi/FansiExtensions.scala index 9c74315..828dace 100644 --- a/src/main/scala/com/github/mrpowers/spark/fast/tests/ufansi/FansiExtensions.scala +++ b/src/main/scala/com/github/mrpowers/spark/fast/tests/ufansi/FansiExtensions.scala @@ -2,9 +2,6 @@ package com.github.mrpowers.spark.fast.tests.ufansi object FansiExtensions { implicit class StrOps(c: Seq[Str]) { def mkStr(start: Str, sep: Str, end: Str): Str = - c.foldLeft(start)((leftAcc: Str, e: Str) => { - val separator = if (leftAcc == start) Str("") else sep - leftAcc ++ separator ++ e - }) ++ end + start ++ c.reduce(_ ++ sep ++ _) ++ end } } \ No newline at end of file From bfddcbb0ad586f08c6bd3ed11c8c3befc4f07f1f Mon Sep 17 00:00:00 2001 From: happytomatoe <2893931+happytomatoe@users.noreply.github.com> Date: Mon, 2 Sep 2024 13:54:02 +0200 Subject: [PATCH 8/9] Refactor --- .../mrpowers/spark/fast/tests/DataframeUtil.scala | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/src/main/scala/com/github/mrpowers/spark/fast/tests/DataframeUtil.scala b/src/main/scala/com/github/mrpowers/spark/fast/tests/DataframeUtil.scala index 1f3f6dc..4de2724 100644 --- a/src/main/scala/com/github/mrpowers/spark/fast/tests/DataframeUtil.scala +++ b/src/main/scala/com/github/mrpowers/spark/fast/tests/DataframeUtil.scala @@ -33,7 +33,8 @@ object DataframeUtil { else { val withEquals = actualSeq .zip(expectedSeq) - .map { case (actualRowField, expectedRowField) => (actualRowField, expectedRowField, actualRowField == expectedRowField) } + .map { case (actualRowField, expectedRowField) => + (actualRowField, expectedRowField, actualRowField == expectedRowField) } val allFieldsAreNotEqual = !withEquals.exists(_._3) if (allFieldsAreNotEqual) { List( @@ -43,10 +44,11 @@ object DataframeUtil { } else { val coloredDiff = withEquals - .map { case (actualRowField, expectedRowField, equal) => - if (equal) + .map { + case (actualRowField, expectedRowField, true) => (DarkGray(actualRowField.toString), DarkGray(expectedRowField.toString)) - else (Red(actualRowField.toString), Green(expectedRowField.toString)) + case (actualRowField, expectedRowField, false) => + (Red(actualRowField.toString), Green(expectedRowField.toString)) } val start = DarkGray("[") val sep = DarkGray(",") From 7a53baf4740e070a7ac8b2d0725fe428f8ac4a16 Mon Sep 17 00:00:00 2001 From: happytomatoe <2893931+happytomatoe@users.noreply.github.com> Date: Tue, 3 Sep 2024 14:08:15 +0200 Subject: [PATCH 9/9] Refactor --- .../com/github/mrpowers/spark/fast/tests/DataframeUtil.scala | 2 +- .../mrpowers/spark/fast/tests/ufansi/FansiExtensions.scala | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/main/scala/com/github/mrpowers/spark/fast/tests/DataframeUtil.scala b/src/main/scala/com/github/mrpowers/spark/fast/tests/DataframeUtil.scala index 4de2724..84bdf1f 100644 --- a/src/main/scala/com/github/mrpowers/spark/fast/tests/DataframeUtil.scala +++ b/src/main/scala/com/github/mrpowers/spark/fast/tests/DataframeUtil.scala @@ -6,7 +6,7 @@ import org.apache.spark.sql.Row import com.github.mrpowers.spark.fast.tests.ufansi.FansiExtensions.StrOps object DataframeUtil { - def showDataframeDiff( + private[mrpowers] def showDataframeDiff( header: (String, String), actual: Array[Row], expected: Array[Row], diff --git a/src/main/scala/com/github/mrpowers/spark/fast/tests/ufansi/FansiExtensions.scala b/src/main/scala/com/github/mrpowers/spark/fast/tests/ufansi/FansiExtensions.scala index 828dace..5af5d3d 100644 --- a/src/main/scala/com/github/mrpowers/spark/fast/tests/ufansi/FansiExtensions.scala +++ b/src/main/scala/com/github/mrpowers/spark/fast/tests/ufansi/FansiExtensions.scala @@ -1,6 +1,6 @@ package com.github.mrpowers.spark.fast.tests.ufansi object FansiExtensions { - implicit class StrOps(c: Seq[Str]) { + private[mrpowers] implicit class StrOps(c: Seq[Str]) { def mkStr(start: Str, sep: Str, end: Str): Str = start ++ c.reduce(_ ++ sep ++ _) ++ end }