Update dependencies

build.gradle

@@ -1,6 +1,8 @@
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+
 plugins {
-    id 'org.jetbrains.kotlin.jvm' version '1.7.21'
-    id 'org.jetbrains.kotlin.plugin.serialization' version '1.7.21'
+    id 'org.jetbrains.kotlin.jvm' version '2.1.10'
+    id 'org.jetbrains.kotlin.plugin.serialization' version '2.1.10'
 }
 
 group 'intro-coroutines'
@@ -13,45 +15,57 @@ repositories {
 dependencies {
     implementation "org.jetbrains.kotlin:kotlin-stdlib"
     implementation "org.jetbrains.kotlin:kotlin-reflect"
-    implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.4.1")
+    implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.8.0")
 
-    def coroutines_version = '1.6.4'
+    def coroutines_version = '1.10.1'
     implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:$coroutines_version"
     implementation "org.jetbrains.kotlinx:kotlinx-coroutines-swing:$coroutines_version"
     implementation "org.jetbrains.kotlinx:kotlinx-coroutines-jdk8:$coroutines_version"
     implementation "org.jetbrains.kotlinx:kotlinx-coroutines-slf4j:$coroutines_version"
     implementation "org.jetbrains.kotlinx:kotlinx-coroutines-debug:$coroutines_version"
 
-    implementation 'ch.qos.logback:logback-classic:1.4.5'
+    implementation 'ch.qos.logback:logback-classic:1.5.16'
 
-    def retrofit_version = '2.9.0'
+    def retrofit_version = '2.11.0'
     implementation "com.squareup.retrofit2:retrofit:$retrofit_version"
     implementation "com.squareup.retrofit2:retrofit-mock:$retrofit_version"
-    implementation "com.jakewharton.retrofit:retrofit2-kotlinx-serialization-converter:0.8.0"
-    implementation 'com.squareup.okhttp3:okhttp:4.10.0'
+    implementation "com.squareup.retrofit2:converter-kotlinx-serialization:$retrofit_version"
+    implementation 'com.squareup.okhttp3:okhttp:4.12.0'
 
-    implementation 'io.reactivex.rxjava2:rxjava:2.2.21'
-    implementation 'io.reactivex.rxjava2:rxkotlin:2.4.0'
-    implementation "com.squareup.retrofit2:adapter-rxjava2:$retrofit_version"
+    implementation 'io.reactivex.rxjava3:rxjava:3.1.10'
+    implementation 'io.reactivex.rxjava3:rxkotlin:3.0.1'
+    implementation "com.squareup.retrofit2:adapter-rxjava3:$retrofit_version"
 
-    testImplementation 'junit:junit:4.13.2'
+    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.12.0'
     testImplementation "org.jetbrains.kotlinx:kotlinx-coroutines-test:$coroutines_version"
+    testRuntimeOnly 'org.junit.platform:junit-platform-launcher:1.12.0'
+    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.12.0'
 }
 
 compileKotlin {
-    kotlinOptions {
-        jvmTarget = "1.8"
-        freeCompilerArgs += "-opt-in=kotlin.RequiresOptIn"
+    compilerOptions {
+        jvmTarget.set(JvmTarget.JVM_21)
+        freeCompilerArgs.add("-opt-in=kotlin.RequiresOptIn")
     }
 }
 
 compileTestKotlin {
-    kotlinOptions {
-        jvmTarget = "1.8"
-        freeCompilerArgs += "-opt-in=kotlin.RequiresOptIn"
+    compilerOptions {
+        jvmTarget.set(JvmTarget.JVM_21)
+        freeCompilerArgs.add("-opt-in=kotlin.RequiresOptIn")
+    }
+}
+
+java {
+    toolchain {
+        languageVersion.set(JavaLanguageVersion.of(21))
     }
 }
 
+test {
+    useJUnitPlatform()
+}
+
 sourceSets {
     main.kotlin.srcDirs = ['src']
     main.resources.srcDirs = ['resources']

gradle/wrapper/gradle-wrapper.properties

@@ -3,4 +3,4 @@ distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.6-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.11-all.zip

src/contributors/GitHubService.kt

@@ -1,15 +1,13 @@
 package contributors
 
-import com.jakewharton.retrofit2.converter.kotlinx.serialization.asConverterFactory
-import kotlinx.serialization.ExperimentalSerializationApi
 import kotlinx.serialization.Serializable
 import kotlinx.serialization.json.Json
 import okhttp3.MediaType.Companion.toMediaType
 import okhttp3.OkHttpClient
 import retrofit2.Call
-import retrofit2.Response
 import retrofit2.Retrofit
-import retrofit2.adapter.rxjava2.RxJava2CallAdapterFactory
+import retrofit2.adapter.rxjava3.RxJava3CallAdapterFactory
+import retrofit2.converter.kotlinx.serialization.asConverterFactory
 import retrofit2.http.GET
 import retrofit2.http.Path
 import java.util.Base64
@@ -46,7 +44,8 @@ data class RequestData(
     val org: String
 )
 
-@OptIn(ExperimentalSerializationApi::class)
+private val json = Json { ignoreUnknownKeys = true }
+
 fun createGitHubService(username: String, password: String): GitHubService {
     val authToken = "Basic " + Base64.getEncoder().encode("$username:$password".toByteArray()).toString(Charsets.UTF_8)
     val httpClient = OkHttpClient.Builder()
@@ -63,8 +62,8 @@ fun createGitHubService(username: String, password: String): GitHubService {
     val contentType = "application/json".toMediaType()
     val retrofit = Retrofit.Builder()
         .baseUrl("https://api.github.com")
-        .addConverterFactory(Json { ignoreUnknownKeys = true }.asConverterFactory(contentType))
-        .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
+        .addConverterFactory(json.asConverterFactory(contentType))
+        .addCallAdapterFactory(RxJava3CallAdapterFactory.create())
         .client(httpClient)
         .build()
     return retrofit.create(GitHubService::class.java)

test/samples/SampleTest.kt

@@ -6,7 +6,7 @@ import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.test.currentTime
 import kotlinx.coroutines.test.runTest
-import org.junit.Test
+import org.junit.jupiter.api.Test
 
 @OptIn(ExperimentalCoroutinesApi::class)
 class SampleTest {

test/tasks/AggregationKtTest.kt

@@ -1,8 +1,8 @@
 package tasks
 
 import contributors.User
-import org.junit.Assert
-import org.junit.Test
+import org.junit.jupiter.api.Assertions
+import org.junit.jupiter.api.Test
 
 class AggregationKtTest {
     @Test
@@ -17,6 +17,6 @@ class AggregationKtTest {
             User("Alice", 8),
             User("Charlie", 3)
         )
-        Assert.assertEquals("Wrong result for 'aggregation'", expected, actual)
+        Assertions.assertEquals(expected, actual, "Wrong result for 'aggregation'")
     }
 }

test/tasks/Request1BlockingKtTest.kt

@@ -3,15 +3,14 @@ package tasks
 import contributors.MockGithubService
 import contributors.expectedResults
 import contributors.testRequestData
-import org.junit.Assert
-import org.junit.Test
+import org.junit.jupiter.api.Assertions
+import org.junit.jupiter.api.Test
 
 class Request1BlockingKtTest {
     @Test
     fun testAggregation() {
         val users = loadContributorsBlocking(MockGithubService, testRequestData)
-        Assert.assertEquals("List of contributors should be sorted " +
-                "by the number of contributions in a descending order",
-            expectedResults.users, users)
+        Assertions.assertEquals(expectedResults.users, users, "List of contributors should be sorted " +
+                "by the number of contributions in a descending order")
     }
 }

test/tasks/Request3CallbacksKtTest.kt

@@ -3,16 +3,15 @@ package tasks
 import contributors.MockGithubService
 import contributors.expectedResults
 import contributors.testRequestData
-import org.junit.Assert
-import org.junit.Test
+import org.junit.jupiter.api.Assertions
+import org.junit.jupiter.api.Test
 
 class Request3CallbacksKtTest {
     @Test
     fun testDataIsLoaded() {
         loadContributorsCallbacks(MockGithubService, testRequestData) {
-            Assert.assertEquals(
-                "Wrong result for 'loadContributorsCallbacks'",
-                expectedResults.users, it
+            Assertions.assertEquals(expectedResults.users, it,
+                "Wrong result for 'loadContributorsCallbacks'"
             )
         }
     }

test/tasks/Request4SuspendKtTest.kt

@@ -4,28 +4,26 @@ import contributors.MockGithubService
 import contributors.expectedResults
 import contributors.testRequestData
 import kotlinx.coroutines.runBlocking
-import org.junit.Assert
-import org.junit.Test
+import org.junit.jupiter.api.Assertions
+import org.junit.jupiter.api.Test
 
 class Request4SuspendKtTest {
     @Test
     fun testSuspend() = runBlocking {
         val startTime = System.currentTimeMillis()
         val result = loadContributorsSuspend(MockGithubService, testRequestData)
-        Assert.assertEquals("Wrong result for 'loadContributorsSuspend'", expectedResults.users, result)
+        Assertions.assertEquals(expectedResults.users, result, "Wrong result for 'loadContributorsSuspend'")
         val totalTime = System.currentTimeMillis() - startTime
         /*
         // TODO: uncomment this assertion
-        Assert.assertEquals(
+        Assertions.assertEquals(expectedResults.timeFromStart, totalTime,
             "The calls run consequently, so the total virtual time should be 4000 ms: " +
-                    "1000 for repos request plus (1000 + 1200 + 800) = 3000 for sequential contributors requests)",
-            expectedResults.timeFromStart, totalTime
+                    "1000 for repos request plus (1000 + 1200 + 800) = 3000 for sequential contributors requests)"
         )
         */
-        Assert.assertTrue(
+        Assertions.assertTrue(totalTime in expectedResults.timeFromStart..(expectedResults.timeFromStart + 500),
             "The calls run consequently, so the total time should be around 4000 ms: " +
-                    "1000 for repos request plus (1000 + 1200 + 800) = 3000 for sequential contributors requests)",
-            totalTime in expectedResults.timeFromStart..(expectedResults.timeFromStart + 500)
+                    "1000 for repos request plus (1000 + 1200 + 800) = 3000 for sequential contributors requests)"
         )
     }
 }

test/tasks/Request5ConcurrentKtTest.kt

@@ -4,28 +4,27 @@ import contributors.MockGithubService
 import contributors.expectedConcurrentResults
 import contributors.testRequestData
 import kotlinx.coroutines.runBlocking
-import org.junit.Assert
-import org.junit.Test
+import org.junit.jupiter.api.Assertions
+import org.junit.jupiter.api.Test
 
 class Request5ConcurrentKtTest {
     @Test
     fun testConcurrent() = runBlocking {
         val startTime = System.currentTimeMillis()
         val result = loadContributorsConcurrent(MockGithubService, testRequestData)
-        Assert.assertEquals("Wrong result for 'loadContributorsConcurrent'", expectedConcurrentResults.users, result)
+        Assertions.assertEquals(expectedConcurrentResults.users, result, "Wrong result for 'loadContributorsConcurrent'")
         val totalTime = System.currentTimeMillis() - startTime
         /*
         // TODO: uncomment this assertion
-        Assert.assertEquals(
+        Assertions.assertEquals(expectedConcurrentResults.timeFromStart, totalTime,
             "The calls run concurrently, so the total virtual time should be 2200 ms: " +
-                    "1000 ms for repos request plus max(1000, 1200, 800) = 1200 ms for concurrent contributors requests)",
-            expectedConcurrentResults.timeFromStart, totalTime
+                    "1000 ms for repos request plus max(1000, 1200, 800) = 1200 ms for concurrent contributors requests)"
         )
         */
-        Assert.assertTrue(
+        Assertions.assertTrue(
+            totalTime in expectedConcurrentResults.timeFromStart..(expectedConcurrentResults.timeFromStart + 500),
             "The calls run concurrently, so the total virtual time should be 2200 ms: " +
-                    "1000 ms for repos request plus max(1000, 1200, 800) = 1200 ms for concurrent contributors requests)",
-            totalTime in expectedConcurrentResults.timeFromStart..(expectedConcurrentResults.timeFromStart + 500)
+                    "1000 ms for repos request plus max(1000, 1200, 800) = 1200 ms for concurrent contributors requests)"
         )
     }
 }

test/tasks/Request6ProgressKtTest.kt

@@ -4,8 +4,8 @@ import contributors.MockGithubService
 import contributors.progressResults
 import contributors.testRequestData
 import kotlinx.coroutines.runBlocking
-import org.junit.Assert
-import org.junit.Test
+import org.junit.jupiter.api.Assertions
+import org.junit.jupiter.api.Test
 
 class Request6ProgressKtTest {
     @Test
@@ -18,10 +18,10 @@ class Request6ProgressKtTest {
             val time = System.currentTimeMillis() - startTime
             /*
             // TODO: uncomment this assertion
-            Assert.assertEquals("Expected intermediate result after virtual ${expected.timeFromStart} ms:",
-                expected.timeFromStart, time)
+            Assertions.assertEquals(expected.timeFromStart, time,
+                "Expected intermediate result after virtual ${expected.timeFromStart} ms:")
             */
-            Assert.assertEquals("Wrong intermediate result after $time:", expected.users, users)
+            Assertions.assertEquals(expected.users, users, "Wrong intermediate result after $time:")
         }
     }
 }

test/tasks/Request7ChannelsKtTest.kt

@@ -4,8 +4,8 @@ import contributors.MockGithubService
 import contributors.concurrentProgressResults
 import contributors.testRequestData
 import kotlinx.coroutines.runBlocking
-import org.junit.Assert
-import org.junit.Test
+import org.junit.jupiter.api.Assertions
+import org.junit.jupiter.api.Test
 
 class Request7ChannelsKtTest {
     @Test
@@ -18,10 +18,10 @@ class Request7ChannelsKtTest {
             val time = System.currentTimeMillis() - startTime
             /*
             // TODO: uncomment this assertion
-            Assert.assertEquals("Expected intermediate result after virtual ${expected.timeFromStart} ms:",
-                expected.timeFromStart, time)
+            Assertions.assertEquals(expected.timeFromStart, time,
+                "Expected intermediate result after virtual ${expected.timeFromStart} ms:")
             */
-            Assert.assertEquals("Wrong intermediate result after $time:", expected.users, users)
+            Assertions.assertEquals(expected.users, users, "Wrong intermediate result after $time:")
         }
     }
 }