Fix test compile after resolving merge conflicts

sql/core/src/test/scala/org/apache/spark/sql/execution/datasources/parquet/ParquetProtobufCompatibilitySuite.scala

@@ -17,11 +17,9 @@
 
 package org.apache.spark.sql.execution.datasources.parquet
 
-import org.apache.spark.sql.test.TestSQLContext
-import org.apache.spark.sql.{DataFrame, Row, SQLContext}
+import org.apache.spark.sql.{DataFrame, Row}
 
 class ParquetProtobufCompatibilitySuite extends ParquetCompatibilityTest {
-  override def sqlContext: SQLContext = TestSQLContext
 
   private def readParquetProtobufFile(name: String): DataFrame = {
     val url = Thread.currentThread().getContextClassLoader.getResource(name)

sql/core/src/test/scala/org/apache/spark/sql/execution/joins/InnerJoinSuite.scala

@@ -17,16 +17,15 @@
 
 package org.apache.spark.sql.execution.joins
 
+import org.apache.spark.sql.{SQLConf, execution, Row, DataFrame}
+import org.apache.spark.sql.catalyst.expressions.Expression
 import org.apache.spark.sql.catalyst.planning.ExtractEquiJoinKeys
 import org.apache.spark.sql.catalyst.plans.Inner
 import org.apache.spark.sql.catalyst.plans.logical.Join
-import org.apache.spark.sql.test.SQLTestUtils
-import org.apache.spark.sql.types.{IntegerType, StringType, StructType}
-import org.apache.spark.sql.{SQLConf, execution, Row, DataFrame}
-import org.apache.spark.sql.catalyst.expressions.Expression
 import org.apache.spark.sql.execution._
+import org.apache.spark.sql.types.{IntegerType, StringType, StructType}
 
-class InnerJoinSuite extends SparkPlanTest with SQLTestUtils {
+class InnerJoinSuite extends SparkPlanTest {
 
   private def testInnerJoin(
       testName: String,
@@ -107,23 +106,25 @@ class InnerJoinSuite extends SparkPlanTest with SQLTestUtils {
   }
 
   {
-    val upperCaseData = sqlContext.createDataFrame(sqlContext.sparkContext.parallelize(Seq(
-      Row(1, "A"),
-      Row(2, "B"),
-      Row(3, "C"),
-      Row(4, "D"),
-      Row(5, "E"),
-      Row(6, "F"),
-      Row(null, "G")
-    )), new StructType().add("N", IntegerType).add("L", StringType))
-
-    val lowerCaseData = sqlContext.createDataFrame(sqlContext.sparkContext.parallelize(Seq(
-      Row(1, "a"),
-      Row(2, "b"),
-      Row(3, "c"),
-      Row(4, "d"),
-      Row(null, "e")
-    )), new StructType().add("n", IntegerType).add("l", StringType))
+    lazy val upperCaseData = ctx.createDataFrame(
+      ctx.sparkContext.parallelize(Seq(
+        Row(1, "A"),
+        Row(2, "B"),
+        Row(3, "C"),
+        Row(4, "D"),
+        Row(5, "E"),
+        Row(6, "F"),
+        Row(null, "G")
+      )), new StructType().add("N", IntegerType).add("L", StringType))
+
+    lazy val lowerCaseData = ctx.createDataFrame(
+      ctx.sparkContext.parallelize(Seq(
+        Row(1, "a"),
+        Row(2, "b"),
+        Row(3, "c"),
+        Row(4, "d"),
+        Row(null, "e")
+      )), new StructType().add("n", IntegerType).add("l", StringType))
 
     testInnerJoin(
       "inner join, one match per row",
@@ -139,42 +140,44 @@ class InnerJoinSuite extends SparkPlanTest with SQLTestUtils {
     )
   }
 
-  private val testData2 = Seq(
-    (1, 1),
-    (1, 2),
-    (2, 1),
-    (2, 2),
-    (3, 1),
-    (3, 2)
-  ).toDF("a", "b")
-
   {
-    val left = testData2.where("a = 1")
-    val right = testData2.where("a = 1")
-    testInnerJoin(
-      "inner join, multiple matches",
-      left,
-      right,
-      (left.col("a") === right.col("a")).expr,
-      Seq(
-        (1, 1, 1, 1),
-        (1, 1, 1, 2),
-        (1, 2, 1, 1),
-        (1, 2, 1, 2)
+    lazy val testData2 = Seq(
+      (1, 1),
+      (1, 2),
+      (2, 1),
+      (2, 2),
+      (3, 1),
+      (3, 2)
+    ).toDF("a", "b")
+
+    {
+      lazy val left = testData2.where("a = 1")
+      lazy val right = testData2.where("a = 1")
+      testInnerJoin(
+        "inner join, multiple matches",
+        left,
+        right,
+        (left.col("a") === right.col("a")).expr,
+        Seq(
+          (1, 1, 1, 1),
+          (1, 1, 1, 2),
+          (1, 2, 1, 1),
+          (1, 2, 1, 2)
+        )
       )
-    )
-  }
+    }
 
-  {
-    val left = testData2.where("a = 1")
-    val right = testData2.where("a = 2")
-    testInnerJoin(
-      "inner join, no matches",
-      left,
-      right,
-      (left.col("a") === right.col("a")).expr,
-      Seq.empty
-    )
+    {
+      lazy val left = testData2.where("a = 1")
+      lazy val right = testData2.where("a = 2")
+      testInnerJoin(
+        "inner join, no matches",
+        left,
+        right,
+        (left.col("a") === right.col("a")).expr,
+        Seq.empty
+      )
+    }
   }
 
 }

sql/core/src/test/scala/org/apache/spark/sql/execution/joins/OuterJoinSuite.scala

@@ -19,9 +19,9 @@ package org.apache.spark.sql.execution.joins
 
 import org.apache.spark.sql.{DataFrame, Row, SQLConf}
 import org.apache.spark.sql.catalyst.planning.ExtractEquiJoinKeys
+import org.apache.spark.sql.catalyst.plans._
 import org.apache.spark.sql.catalyst.plans.logical.Join
 import org.apache.spark.sql.catalyst.expressions._
-import org.apache.spark.sql.catalyst.plans._
 import org.apache.spark.sql.execution.{EnsureRequirements, joins, SparkPlan, SparkPlanTest}
 import org.apache.spark.sql.types.{IntegerType, DoubleType, StructType}
 
@@ -53,7 +53,7 @@ class OuterJoinSuite extends SparkPlanTest {
       Row(null, null)
     )), new StructType().add("c", IntegerType).add("d", DoubleType))
 
-  private val condition = {
+  private lazy val condition = {
     And((left.col("a") === right.col("c")).expr,
       LessThan(left.col("b").expr, right.col("d").expr))
   }

sql/core/src/test/scala/org/apache/spark/sql/sources/DataSourceTest.scala

@@ -23,11 +23,14 @@ import org.apache.spark.sql._
 import org.apache.spark.sql.test.SQLTestUtils
 
 
-abstract class DataSourceTest extends QueryTest with BeforeAndAfter with SQLTestUtils {
+private[sql] abstract class DataSourceTest extends AbstractDataSourceTest with SQLTestUtils
+
+private[sql] abstract class AbstractDataSourceTest extends QueryTest with BeforeAndAfter {
+  protected def _sqlContext: SQLContext
 
   // We want to test some edge cases.
   protected lazy val caseInsensitiveContext: SQLContext = {
-    val ctx = new SQLContext(sqlContext.sparkContext)
+    val ctx = new SQLContext(_sqlContext.sparkContext)
     ctx.setConf(SQLConf.CASE_SENSITIVE, false)
     ctx
   }

sql/hive/src/test/java/org/apache/spark/sql/hive/test/HiveDataSourceTest.scala

@@ -0,0 +1,28 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.spark.sql.hive.test
+
+import org.apache.spark.sql.sources.AbstractDataSourceTest
+
+
+/**
+ * An equivalent of [[org.apache.spark.sql.sources.DataSourceTest]], but for hive tests.
+ */
+private[hive] abstract class HiveDataSourceTest
+  extends AbstractDataSourceTest
+  with HiveTestUtils

sql/hive/src/test/java/org/apache/spark/sql/hive/test/HiveParquetCompatibilityTest.scala

@@ -17,7 +17,7 @@
 
 package org.apache.spark.sql.hive.test
 
-import org.apache.spark.sql.parquet.AbstractParquetCompatibilityTest
+import org.apache.spark.sql.execution.datasources.parquet.AbstractParquetCompatibilityTest
 
 /**
  * Helper class for testing Parquet compatibility in hive.

sql/hive/src/test/java/org/apache/spark/sql/hive/test/HiveParquetTest.scala

@@ -17,7 +17,7 @@
 
 package org.apache.spark.sql.hive.test
 
-import org.apache.spark.sql.parquet.AbstractParquetTest
+import org.apache.spark.sql.execution.datasources.parquet.AbstractParquetTest
 
 /**
  * Helper trait for Parquet tests analogous to [[org.apache.spark.sql.parquet.ParquetTest]].

sql/hive/src/test/scala/org/apache/spark/sql/hive/HiveMetastoreCatalogSuite.scala

@@ -22,8 +22,7 @@ import java.io.File
 import org.apache.spark.{Logging, SparkFunSuite}
 import org.apache.spark.sql.{Row, SaveMode}
 import org.apache.spark.sql.hive.client.{ExternalTable, ManagedTable}
-import org.apache.spark.sql.hive.test.HiveTestUtils
-import org.apache.spark.sql.sources.DataSourceTest
+import org.apache.spark.sql.hive.test.{HiveDataSourceTest, HiveTestUtils}
 import org.apache.spark.sql.test.ExamplePointUDT
 import org.apache.spark.sql.types.StructType
 
@@ -51,8 +50,10 @@ class HiveMetastoreCatalogSuite extends SparkFunSuite with HiveTestUtils with Lo
   }
 }
 
-class DataSourceWithHiveMetastoreCatalogSuite extends DataSourceTest with HiveTestUtils {
-  private val testDF = (1 to 2).map(i => (i, s"val_$i")).toDF("d1", "d2").coalesce(1)
+class DataSourceWithHiveMetastoreCatalogSuite extends HiveDataSourceTest {
+  import testImplicits._
+
+  private lazy val testDF = (1 to 2).map(i => (i, s"val_$i")).toDF("d1", "d2").coalesce(1)
 
   Seq(
     "parquet" -> (
@@ -75,7 +76,7 @@ class DataSourceWithHiveMetastoreCatalogSuite extends DataSourceTest with HiveTe
           .format(provider)
           .saveAsTable("t")
 
-        val hiveTable = catalog.client.getTable("default", "t")
+        val hiveTable = ctx.catalog.client.getTable("default", "t")
         assert(hiveTable.inputFormat === Some(inputFormat))
         assert(hiveTable.outputFormat === Some(outputFormat))
         assert(hiveTable.serde === Some(serde))
@@ -87,8 +88,8 @@ class DataSourceWithHiveMetastoreCatalogSuite extends DataSourceTest with HiveTe
         assert(columns.map(_.name) === Seq("d1", "d2"))
         assert(columns.map(_.hiveType) === Seq("int", "string"))
 
-        checkAnswer(table("t"), testDF)
-        assert(runSqlHive("SELECT * FROM t") === Seq("1\tval_1", "2\tval_2"))
+        checkAnswer(ctx.table("t"), testDF)
+        assert(ctx.runSqlHive("SELECT * FROM t") === Seq("1\tval_1", "2\tval_2"))
       }
     }
 
@@ -104,7 +105,7 @@ class DataSourceWithHiveMetastoreCatalogSuite extends DataSourceTest with HiveTe
             .option("path", path.toString)
             .saveAsTable("t")
 
-          val hiveTable = catalog.client.getTable("default", "t")
+          val hiveTable = ctx.catalog.client.getTable("default", "t")
           assert(hiveTable.inputFormat === Some(inputFormat))
           assert(hiveTable.outputFormat === Some(outputFormat))
           assert(hiveTable.serde === Some(serde))
@@ -116,8 +117,8 @@ class DataSourceWithHiveMetastoreCatalogSuite extends DataSourceTest with HiveTe
           assert(columns.map(_.name) === Seq("d1", "d2"))
           assert(columns.map(_.hiveType) === Seq("int", "string"))
 
-          checkAnswer(table("t"), testDF)
-          assert(runSqlHive("SELECT * FROM t") === Seq("1\tval_1", "2\tval_2"))
+          checkAnswer(ctx.table("t"), testDF)
+          assert(ctx.runSqlHive("SELECT * FROM t") === Seq("1\tval_1", "2\tval_2"))
         }
       }
     }
@@ -127,13 +128,13 @@ class DataSourceWithHiveMetastoreCatalogSuite extends DataSourceTest with HiveTe
         withTable("t") {
           val path = dir.getCanonicalPath
 
-          sql(
+          ctx.sql(
             s"""CREATE TABLE t USING $provider
                |OPTIONS (path '$path')
                |AS SELECT 1 AS d1, "val_1" AS d2
              """.stripMargin)
 
-          val hiveTable = catalog.client.getTable("default", "t")
+          val hiveTable = ctx.catalog.client.getTable("default", "t")
           assert(hiveTable.inputFormat === Some(inputFormat))
           assert(hiveTable.outputFormat === Some(outputFormat))
           assert(hiveTable.serde === Some(serde))
@@ -146,8 +147,8 @@ class DataSourceWithHiveMetastoreCatalogSuite extends DataSourceTest with HiveTe
           assert(columns.map(_.name) === Seq("d1", "d2"))
           assert(columns.map(_.hiveType) === Seq("int", "string"))
 
-          checkAnswer(table("t"), Row(1, "val_1"))
-          assert(runSqlHive("SELECT * FROM t") === Seq("1\tval_1"))
+          checkAnswer(ctx.table("t"), Row(1, "val_1"))
+          assert(ctx.runSqlHive("SELECT * FROM t") === Seq("1\tval_1"))
         }
       }
     }

sql/hive/src/test/scala/org/apache/spark/sql/hive/HiveParquetSuite.scala

@@ -17,13 +17,8 @@
 
 package org.apache.spark.sql.hive
 
-<<<<<<< HEAD
-import org.apache.spark.sql.hive.test.HiveParquetTest
-=======
-import org.apache.spark.sql.hive.test.TestHive
-import org.apache.spark.sql.execution.datasources.parquet.ParquetTest
->>>>>>> 3c9802d9400bea802984456683b2736a450ee17e
 import org.apache.spark.sql.{QueryTest, Row}
+import org.apache.spark.sql.hive.test.HiveParquetTest
 
 case class Cases(lower: String, UPPER: String)
 

sql/hive/src/test/scala/org/apache/spark/sql/hive/MetastoreDataSourcesSuite.scala

@@ -475,7 +475,7 @@ class MetastoreDataSourcesSuite
           // Drop table will also delete the data.
           ctx.sql("DROP TABLE savedJsonTable")
           intercept[IOException] {
-            ctx.read.json(catalog.hiveDefaultTableFilePath("savedJsonTable"))
+            ctx.read.json(ctx.catalog.hiveDefaultTableFilePath("savedJsonTable"))
           }
         }