diff --git a/build.sbt b/build.sbt
index 007c263..d88acf0 100644
--- a/build.sbt
+++ b/build.sbt
@@ -4,7 +4,8 @@
 ThisBuild / organizationName := "Alex Tucker"
 ThisBuild / assemblyPrependShellScript := Some(defaultShellScript)
 ThisBuild / assemblyMergeStrategy := {
-  case "module-info.class" => MergeStrategy.discard
+  case PathList("module-info.class") => MergeStrategy.last
+  case path if path.endsWith("/module-info.class") => MergeStrategy.last
   case PathList("org", "apache", "commons", "logging", xs @ _*)         => MergeStrategy.first
   case PathList("org", "apache", "jena", "tdb", "tdb-properties.xml")   => MergeStrategy.first
   case x =>
@@ -18,13 +19,13 @@
     version := "1.4",
     Compile / mainClass := Some("uk.org.floop.sparqlTestRunner.SparqlTestRunner"),
     libraryDependencies ++= Seq(
-      "org.apache.jena" % "jena-arq" % "3.17.0",
-      "org.apache.jena" % "jena-cmds" % "3.17.0",
+      "org.apache.jena" % "jena-arq" % "4.10.0",
+      "org.apache.jena" % "jena-cmds" % "4.10.0",
       "com.github.scopt" %% "scopt" % "4.0.1",
       "org.scala-lang.modules" %% "scala-xml" % "2.0.0",
       "org.slf4j" % "slf4j-simple" % "1.7.30",
       "com.typesafe.scala-logging" %% "scala-logging" % "3.9.4",
-      "xerces" % "xercesImpl" % "2.12.1",
+      "xerces" % "xercesImpl" % "2.12.2",
       "org.scalactic" %% "scalactic" % "3.2.9" % Test,
       "org.scalatest" %% "scalatest" % "3.2.9" % Test,
       "org.scalatest" %% "scalatest-flatspec" % "3.2.9" % Test,
diff --git a/src/main/scala/uk/org/floop/sparqlTestRunner/SparqlTestRunner.scala b/src/main/scala/uk/org/floop/sparqlTestRunner/SparqlTestRunner.scala
index e9d8b6f..d22af84 100644
--- a/src/main/scala/uk/org/floop/sparqlTestRunner/SparqlTestRunner.scala
+++ b/src/main/scala/uk/org/floop/sparqlTestRunner/SparqlTestRunner.scala
@@ -17,29 +17,23 @@
 package uk.org.floop.sparqlTestRunner
 
 import com.typesafe.scalalogging.LazyLogging
-import org.apache.http.HttpHeaders
-import org.apache.http.auth.{AuthScope, UsernamePasswordCredentials}
-import org.apache.http.client.protocol.HttpClientContext
-import org.apache.http.client.utils.URIUtils
-import org.apache.http.impl.auth.BasicScheme
-import org.apache.http.impl.client.{BasicAuthCache, BasicCredentialsProvider, HttpClients}
-import org.apache.http.message.BasicHeader
-import org.apache.jena.query._
-import org.apache.jena.riot.{RDFDataMgr, RDFFormat}
+import org.apache.jena.http.auth.AuthEnv
+import org.apache.jena.query.*
+import org.apache.jena.riot.RDFDataMgr
 import org.apache.jena.riot.system.RiotLib
-import org.apache.jena.sparql.engine.http.{QueryEngineHTTP, QueryExceptionHTTP}
+import org.apache.jena.sparql.engine.http.QueryExceptionHTTP
+import org.apache.jena.sparql.exec.http.{QueryExecutionHTTP, QueryExecutionHTTPBuilder}
 import org.apache.jena.sparql.mgt.Explain
 import scopt.OptionParser
 
-import java.io._
+import java.io.*
 import java.net.URI
 import java.nio.charset.StandardCharsets
 import java.nio.file.{Files, Path}
-import java.util
 import scala.io.Source
+import scala.jdk.CollectionConverters.*
 import scala.util.Using
 import scala.xml.{NodeSeq, PCData, XML}
-import scala.jdk.CollectionConverters._
 
 case class Config(dirs: List[File] = List.empty,
                   report: File = new File("reports/TESTS-sparql-test-runner.xml"),
@@ -138,33 +132,22 @@
     parser.parse(args, Config()) match {
       case Some(config) =>
         val queryExecution: Query => QueryExecution = {
-          val execForQuery: (Query => QueryExecution) = config.endpoint match {
+          val execBuilderForQuery: (Query => QueryExecutionBuilder) = config.endpoint match {
             case Some(uri) =>
               // Querying a remote endpoint; if authentication is required, need to set up pre-emptive auth,
               // see https://hc.apache.org/httpcomponents-client-ga/tutorial/html/authentication.html
               config.auth match {
                 case Some(Left(userpass)) =>
-                  val target = URIUtils.extractHost(uri) // new HttpHost(uri.getHost, uri.getPort)
-                  val credsProvider = new BasicCredentialsProvider()
-                  credsProvider.setCredentials(
-                    new AuthScope(target.getHostName, target.getPort),
-                    new UsernamePasswordCredentials(userpass))
-                  val authCache = new BasicAuthCache()
-                  authCache.put(target, new BasicScheme())
-                  val context = HttpClientContext.create()
-                  context.setCredentialsProvider(credsProvider)
-                  context.setAuthCache(authCache)
-                  val client = HttpClients.custom.build()
-                  (query: Query) => QueryExecutionFactory.sparqlService(uri.toString, query, client, context)
+                  val (user, pass) = { userpass.indexOf(':') match {
+                    case -1 => (userpass, null)
+                    case i => (userpass.substring(0, i), userpass.substring(i+1))
+                  }}
+                  AuthEnv.get.registerUsernamePassword(uri, user, pass)
                 case Some(Right(token)) =>
-                  val authHeader = new BasicHeader(HttpHeaders.AUTHORIZATION, "Bearer " + token)
-                  val headers = new util.ArrayList[BasicHeader]
-                  headers.add(authHeader)
-                  val client = HttpClients.custom.setDefaultHeaders(headers).build()
-                  (query: Query) => QueryExecutionFactory.sparqlService(uri.toString, query, client)
+                  AuthEnv.get.setBearerToken(uri.toString, token)
                 case None =>
-                  (query: Query) => QueryExecutionFactory.sparqlService(uri.toString, query)
               }
+              (query: Query) => QueryExecutionHTTP.service(uri.toString).query(query)
             case None =>
               val dataset = DatasetFactory.create
               for (d <- config.data) {
@@ -173,24 +156,24 @@
                 dataset.addNamedModel(d.toURI.toString, model)
               }
               dataset.setDefaultModel(dataset.getUnionModel)
-              (query: Query) => QueryExecutionFactory.create(query, dataset)
+              (query: Query) => QueryExecutionDatasetBuilder.create.query(query).dataset(dataset)
           }
           // Add query timeout, FROMs, etc.
           (query: Query) => {
-            val exec = execForQuery(query)
+            val execBuilder = execBuilderForQuery(query)
             config.maxTime match {
-              case Some(t) => exec.setTimeout(t * 1000)
+              case Some(t) => execBuilder.timeout(t * 1000)
               case None =>
             }
             // if this is an HTTP executor, then we can add the FROM graphs as part of the protocol
-            exec match {
-              case httpExec: QueryEngineHTTP =>
+            execBuilder match {
+              case httpExec: QueryExecutionHTTPBuilder =>
                 for (g <- config.froms) {
-                  httpExec.addDefaultGraph(g)
+                  httpExec.addDefaultGraphURI(g)
                 }
               case _ =>
             }
-            exec
+            execBuilder.build
           }
         }
         (queryExecution, config, config.dirs match {
diff --git a/src/test/scala/uk/org/floop/ProtocolTests.scala b/src/test/scala/uk/org/floop/ProtocolTests.scala
index 049064d..611bbff 100644
--- a/src/test/scala/uk/org/floop/ProtocolTests.scala
+++ b/src/test/scala/uk/org/floop/ProtocolTests.scala
@@ -13,11 +13,11 @@
 class ProtocolTests extends AnyFlatSpec with BeforeAndAfterEach {
   private val wireMockServer = new WireMockServer(wireMockConfig().dynamicPort())
 
-  override def beforeEach: Unit = {
+  override def beforeEach() = {
     wireMockServer.start()
   }
 
-  override def afterEach: Unit = {
+  override def afterEach() = {
     wireMockServer.stop()
   }