diff --git a/README.md b/README.md
index 2037d405..4ee9f76e 100644
--- a/README.md
+++ b/README.md
@@ -45,7 +45,7 @@ There are a few open-source projects that can convert Java objects to JSON. Howe
 Gradle:
 ```gradle
 dependencies {
-  implementation 'com.google.code.gson:gson:2.10'
+  implementation 'com.google.code.gson:gson:2.10.1'
 }
 ```
 
@@ -54,7 +54,7 @@ Maven:
 <dependency>
   <groupId>com.google.code.gson</groupId>
   <artifactId>gson</artifactId>
-  <version>2.10</version>
+  <version>2.10.1</version>
 </dependency>
 ```
 
@@ -83,9 +83,10 @@ see [`GsonBuilder.disableJdkUnsafe()`](https://javadoc.io/doc/com.google.code.gs
 
 ### Documentation
   * [API Javadoc](https://www.javadoc.io/doc/com.google.code.gson/gson): Documentation for the current release
-  * [User guide](https://github.com/google/gson/blob/master/UserGuide.md): This guide contains examples on how to use Gson in your code.
-  * [Change log](https://github.com/google/gson/blob/master/CHANGELOG.md): Changes in the recent versions
-  * [Design document](https://github.com/google/gson/blob/master/GsonDesignDocument.md): This document discusses issues we faced while designing Gson. It also includes a comparison of Gson with other Java libraries that can be used for Json conversion
+  * [User guide](UserGuide.md): This guide contains examples on how to use Gson in your code
+  * [Troubleshooting guide](Troubleshooting.md): Describes how to solve common issues when using Gson
+  * [Change log](CHANGELOG.md): Changes in the recent versions
+  * [Design document](GsonDesignDocument.md): This document discusses issues we faced while designing Gson. It also includes a comparison of Gson with other Java libraries that can be used for Json conversion
 
 Please use the ['gson' tag on StackOverflow](https://stackoverflow.com/questions/tagged/gson) or the [google-gson Google group](https://groups.google.com/group/google-gson) to discuss Gson or to post questions.
 
diff --git a/Troubleshooting.md b/Troubleshooting.md
new file mode 100644
index 00000000..2f9185a3
--- /dev/null
+++ b/Troubleshooting.md
@@ -0,0 +1,212 @@
+# Troubleshooting Guide
+
+This guide describes how to troubleshoot common issues when using Gson.
+
+## `ClassCastException` when using deserialized object
+
+**Symptom:** `ClassCastException` is thrown when accessing an object deserialized by Gson
+
+**Reason:** Your code is most likely not type-safe
+
+**Solution:** Make sure your code adheres to the following:
+
+- Avoid raw types: Instead of calling `fromJson(..., List.class)`, create for example a `TypeToken<List<MyClass>>`.
+  See the [user guide](UserGuide.md#collections-examples) for more information.
+- When using `TypeToken` prefer the `Gson.fromJson` overloads with `TypeToken` parameter such as [`fromJson(Reader, TypeToken)`](https://www.javadoc.io/doc/com.google.code.gson/gson/latest/com.google.gson/com/google/gson/Gson.html#fromJson(java.io.Reader,com.google.gson.reflect.TypeToken)).
+  The overloads with `Type` parameter do not provide any type-safety guarantees.
+- When using `TypeToken` make sure you don't capture a type variable. For example avoid something like `new TypeToken<List<T>>()` (where `T` is a type variable). Due to Java type erasure the actual type of `T` is not available at runtime. Refactor your code to pass around `TypeToken` instances or use [`TypeToken.getParameterized(...)`](https://www.javadoc.io/doc/com.google.code.gson/gson/latest/com.google.gson/com/google/gson/reflect/TypeToken.html#getParameterized(java.lang.reflect.Type,java.lang.reflect.Type...)), for example `TypeToken.getParameterized(List.class, elementClass)`.
+
+## `InaccessibleObjectException`: 'module ... does not "opens ..." to unnamed module'
+
+**Symptom:** An exception with a message in the form 'module ... does not "opens ..." to unnamed module' is thrown
+
+**Reason:** You use Gson by accident to access internal fields of third-party classes
+
+**Solution:** Write custom Gson [`TypeAdapter`](https://www.javadoc.io/doc/com.google.code.gson/gson/latest/com.google.gson/com/google/gson/TypeAdapter.html) implementations for the affected classes or change the type of your data. If this occurs for a field in one of your classes which you did not actually want to serialize or deserialize in the first place, you can exclude that field, see the [user guide](UserGuide.md#excluding-fields-from-serialization-and-deserialization).
+
+**Explanation:**
+
+When no built-in adapter for a type exists and no custom adapter has been registered, Gson falls back to using reflection to access the fields of a class (including `private` ones). Most likely you are seeing this error because you (by accident) rely on the reflection-based adapter for third-party classes. That should be avoided because you make yourself dependent on the implementation details of these classes which could change at any point. For the JDK it is also not possible anymore to access internal fields using reflection starting with JDK 17, see [JEP 403](https://openjdk.org/jeps/403).
+
+If you want to prevent using reflection on third-party classes in the future you can write your own [`ReflectionAccessFilter`](https://www.javadoc.io/doc/com.google.code.gson/gson/latest/com.google.gson/com/google/gson/ReflectionAccessFilter.html) or use one of the predefined ones, such as `ReflectionAccessFilter.BLOCK_ALL_PLATFORM`.
+
+## `InaccessibleObjectException`: 'module ... does not "opens ..." to module com.google.gson'
+
+**Symptom:** An exception with a message in the form 'module ... does not "opens ..." to module com.google.gson' is thrown
+
+**Reason:**
+
+- If the reported package is your own package then you have not configured the module declaration of your project to allow Gson to use reflection on your classes.
+- If the reported package is from a third party library or the JDK see [this troubleshooting point](#inaccessibleobjectexception-module--does-not-opens--to-unnamed-module).
+
+**Solution:** Make sure the `module-info.java` file of your project allows Gson to use reflection on your classes, for example:
+
+```java
+module mymodule {
+    requires com.google.gson;
+
+    opens mypackage to com.google.gson;
+}
+```
+
+Or in case this occurs for a field in one of your classes which you did not actually want to serialize or deserialize in the first place, you can exclude that field, see the [user guide](UserGuide.md#excluding-fields-from-serialization-and-deserialization).
+
+## Android app not working in Release mode; random property names
+
+**Symptom:** Your Android app is working fine in Debug mode but fails in Release mode and the JSON properties have seemingly random names such as `a`, `b`, ...
+
+**Reason:** You probably have not configured ProGuard / R8 correctly
+
+**Solution:** Make sure you have configured ProGuard / R8 correctly to preserve the names of your fields. See the [Android example](examples/android-proguard-example/README.md) for more information.
+
+## Android app unable to parse JSON after app update
+
+**Symptom:** You released a new version of your Android app and it fails to parse JSON data created by the previous version of your app
+
+**Reason:** You probably have not configured ProGuard / R8 correctly; probably the fields names are being obfuscated and their naming changed between the versions of your app
+
+**Solution:** Make sure you have configured ProGuard / R8 correctly to preserve the names of your fields. See the [Android example](examples/android-proguard-example/README.md) for more information.
+
+If you want to preserve backward compatibility for you app you can use [`@SerializedName`](https://www.javadoc.io/doc/com.google.code.gson/gson/latest/com.google.gson/com/google/gson/annotations/SerializedName.html) on the fields to specify the obfuscated name as alternate, for example: `@SerializedName(value = "myprop", alternate = "a")`
+
+Normally ProGuard and R8 produce a mapping file, this makes it easier to find out the obfuscated field names instead of having to find them out through trial and error or other means. See the [Android Studio user guide](https://developer.android.com/studio/build/shrink-code.html#retracing) for more information.
+
+## Default field values not present after deserialization
+
+**Symptom:** You have assign default values to fields but after deserialization the fields have their standard value (such as `null` or `0`)
+
+**Reason:** Gson cannot invoke the constructor of your class and falls back to JDK `Unsafe` (or similar means)
+
+**Solution:** Make sure that the class:
+
+- is `static` (explicitly or implicitly when it is a top-level class)
+- has a no-args constructor
+
+Otherwise Gson will by default try to use JDK `Unsafe` or similar means to create an instance of your class without invoking the constructor and without running any initializers. You can also disable that behavior through [`GsonBuilder.disableJdkUnsafe()`](https://www.javadoc.io/doc/com.google.code.gson/gson/latest/com.google.gson/com/google/gson/GsonBuilder.html#disableJdkUnsafe()) to notice such issues early on.
+
+## `null` values for anonymous and local classes
+
+**Symptom:** Objects of a class are always serialized as JSON `null` / always deserialized as Java `null`
+
+**Reason:** The class you are serializing or deserializing is an anonymous or a local class (or you have specified a custom `ExclusionStrategy`)
+
+**Solution:** Convert the class to a `static` nested class. If the class is already `static` make sure you have not specified a Gson `ExclusionStrategy` which might exclude the class.
+
+Notes:
+
+- "double brace-initialization" also creates anonymous classes
+- Local record classes (feature added in Java 16) are supported by Gson and are not affected by this
+
+## Map keys having unexpected format in JSON
+
+**Symptom:** JSON output for `Map` keys is unexpected / cannot be deserialized again
+
+**Reason:** The `Map` key type is 'complex' and you have not configured the `GsonBuilder` properly
+
+**Solution:** Use [`GsonBuilder.enableComplexMapKeySerialization()`](https://www.javadoc.io/doc/com.google.code.gson/gson/latest/com.google.gson/com/google/gson/GsonBuilder.html#enableComplexMapKeySerialization()). See also the [user guide](UserGuide.md#maps-examples) for more information.
+
+## Parsing JSON fails with `MalformedJsonException`
+
+**Symptom:** JSON parsing fails with `MalformedJsonException`
+
+**Reason:** The JSON data is actually malformed
+
+**Solution:** During debugging log the JSON data right before calling Gson methods or set a breakpoint to inspect the data and make sure it has the expected format. Sometimes APIs might return HTML error pages (instead of JSON data) when reaching rate limits or when other errors occur. Also read the location information of the `MalformedJsonException` exception message, it indicates where exactly in the document the malformed data was detected, including the [JSONPath](https://goessner.net/articles/JsonPath/).
+
+## Integral JSON number is parsed as `double`
+
+**Symptom:** JSON data contains an integral number such as `45` but Gson returns it as `double`
+
+**Reason:** When parsing a JSON number as `Object`, Gson will by default create always return a `double`
+
+**Solution:** Use [`GsonBuilder.setObjectToNumberStrategy`](https://www.javadoc.io/doc/com.google.code.gson/gson/latest/com.google.gson/com/google/gson/GsonBuilder.html#setObjectToNumberStrategy(com.google.gson.ToNumberStrategy)) to specify what type of number should be returned
+
+## Malformed JSON not rejected
+
+**Symptom:** Gson parses malformed JSON without throwing any exceptions
+
+**Reason:** Due to legacy reasons Gson performs parsing by default in lenient mode
+
+**Solution:** See [`Gson` class documentation](https://www.javadoc.io/doc/com.google.code.gson/gson/latest/com.google.gson/com/google/gson/Gson.html) section "Lenient JSON handling"
+
+Note: Even in non-lenient mode Gson deviates slightly from the JSON specification, see [`JsonReader.setLenient`](https://www.javadoc.io/doc/com.google.code.gson/gson/latest/com.google.gson/com/google/gson/stream/JsonReader.html#setLenient(boolean)) for more details.
+
+## `IllegalStateException`: "Expected ... but was ..."
+
+**Symptom:** An `IllegalStateException` with a message in the form "Expected ... but was ..." is thrown
+
+**Reason:** The JSON data does not have the correct format
+
+**Solution:** Make sure that your classes correctly model the JSON data. Also during debugging log the JSON data right before calling Gson methods or set a breakpoint to inspect the data and make sure it has the expected format. Read the location information of the exception message, it indicates where exactly in the document the error occurred, including the [JSONPath](https://goessner.net/articles/JsonPath/).
+
+## `IllegalStateException`: "Expected ... but was NULL"
+
+**Symptom:** An `IllegalStateException` with a message in the form "Expected ... but was NULL" is thrown
+
+**Reason:** You have written a custom `TypeAdapter` which does not properly handle a JSON null value
+
+**Solution:** Add code similar to the following at the beginning of the `read` method of your adapter:
+
+```java
+@Override
+public MyClass read(JsonReader in) throws IOException {
+    if (in.peek() == JsonToken.NULL) {
+        in.nextNull();
+        return null;
+    }
+    
+    ...
+}
+```
+
+Alternatively you can call [`nullSafe()`](https://www.javadoc.io/doc/com.google.code.gson/gson/latest/com.google.gson/com/google/gson/TypeAdapter.html#nullSafe()) on the adapter instance you created.
+
+## Properties missing in JSON
+
+**Symptom:** Properties are missing in the JSON output
+
+**Reason:** Gson by default omits JSON null from the output (or: ProGuard / R8 is not configured correctly and removed unused fields)
+
+**Solution:** Use [`GsonBuilder.serializeNulls()`](https://www.javadoc.io/doc/com.google.code.gson/gson/latest/com.google.gson/com/google/gson/GsonBuilder.html#serializeNulls())
+
+Note: Gson does not support anonymous and local classes and will serialize them as JSON null, see the [related troubleshooting point](#null-values-for-anonymous-and-local-classes).
+
+## JSON output changes for newer Android versions
+
+**Symptom:** The JSON output differs when running on newer Android versions
+
+**Reason:** You use Gson by accident to access internal fields of Android classes
+
+**Solution:** Write custom Gson [`TypeAdapter`](https://www.javadoc.io/doc/com.google.code.gson/gson/latest/com.google.gson/com/google/gson/TypeAdapter.html) implementations for the affected classes or change the type of your data
+
+**Explanation:**
+
+When no built-in adapter for a type exists and no custom adapter has been registered, Gson falls back to using reflection to access the fields of a class (including `private` ones). Most likely you are experiencing this issue because you (by accident) rely on the reflection-based adapter for Android classes. That should be avoided because you make yourself dependent on the implementation details of these classes which could change at any point.
+
+If you want to prevent using reflection on third-party classes in the future you can write your own [`ReflectionAccessFilter`](https://www.javadoc.io/doc/com.google.code.gson/gson/latest/com.google.gson/com/google/gson/ReflectionAccessFilter.html) or use one of the predefined ones, such as `ReflectionAccessFilter.BLOCK_ALL_PLATFORM`.
+
+## JSON output contains values of `static` fields
+
+**Symptom:** The JSON output contains values of `static` fields
+
+**Reason:** You used `GsonBuilder.excludeFieldsWithModifiers` to overwrite the default excluded modifiers
+
+**Solution:** When calling `GsonBuilder.excludeFieldsWithModifiers` you overwrite the default excluded modifiers. Therefore, you have to explicitly exclude `static` fields if desired. This can be done by adding `Modifier.STATIC` as additional argument.
+
+## `NoSuchMethodError` when calling Gson methods
+
+**Symptom:** A `java.lang.NoSuchMethodError` is thrown when trying to call certain Gson methods
+
+**Reason:**
+
+- You have multiple versions of Gson on your classpath
+- Or, the Gson version you compiled against is different from the one on your classpath
+- Or, you are using a code shrinking tool such as ProGuard or R8 which removed methods from Gson
+
+**Solution:** First disable any code shrinking tools such as ProGuard or R8 and check if the issue persists. If not, you have to tweak the configuration of that tool to not modify Gson classes. Otherwise verify that the Gson JAR on your classpath is the same you are compiling against, and that there is only one Gson JAR on your classpath. See [this Stack Overflow question](https://stackoverflow.com/q/227486) to find out where a class is loaded from. For example, for debugging you could include the following code:
+
+```java
+System.out.println(Gson.class.getProtectionDomain().getCodeSource().getLocation());
+```
+
+If that fails with a `NullPointerException` you have to try one of the other ways to find out where a class is loaded from.
diff --git a/UserGuide.md b/UserGuide.md
index b82bd725..05380671 100644
--- a/UserGuide.md
+++ b/UserGuide.md
@@ -1,48 +1,48 @@
 # Gson User Guide
 
-1. [Overview](#TOC-Overview)
-2. [Goals for Gson](#TOC-Goals-for-Gson)
-3. [Gson Performance and Scalability](#TOC-Gson-Performance-and-Scalability)
-4. [Gson Users](#TOC-Gson-Users)
-5. [Using Gson](#TOC-Using-Gson)
-   * [Using Gson with Gradle/Android](#TOC-Gson-With-Gradle)
-   * [Using Gson with Maven](#TOC-Gson-With-Maven)
-   * [Primitives Examples](#TOC-Primitives-Examples)
-   * [Object Examples](#TOC-Object-Examples)
-   * [Finer Points with Objects](#TOC-Finer-Points-with-Objects)
-   * [Nested Classes (including Inner Classes)](#TOC-Nested-Classes-including-Inner-Classes-)
-   * [Array Examples](#TOC-Array-Examples)
-   * [Collections Examples](#TOC-Collections-Examples)
-     * [Collections Limitations](#TOC-Collections-Limitations)
-   * [Maps Examples](#TOC-Maps-Examples)
-   * [Serializing and Deserializing Generic Types](#TOC-Serializing-and-Deserializing-Generic-Types)
-   * [Serializing and Deserializing Collection with Objects of Arbitrary Types](#TOC-Serializing-and-Deserializing-Collection-with-Objects-of-Arbitrary-Types)
-   * [Built-in Serializers and Deserializers](#TOC-Built-in-Serializers-and-Deserializers)
-   * [Custom Serialization and Deserialization](#TOC-Custom-Serialization-and-Deserialization)
-     * [Writing a Serializer](#TOC-Writing-a-Serializer)
-     * [Writing a Deserializer](#TOC-Writing-a-Deserializer)
-   * [Writing an Instance Creator](#TOC-Writing-an-Instance-Creator)
-     * [InstanceCreator for a Parameterized Type](#TOC-InstanceCreator-for-a-Parameterized-Type)
-   * [Compact Vs. Pretty Printing for JSON Output Format](#TOC-Compact-Vs.-Pretty-Printing-for-JSON-Output-Format)
-   * [Null Object Support](#TOC-Null-Object-Support)
-   * [Versioning Support](#TOC-Versioning-Support)
-   * [Excluding Fields From Serialization and Deserialization](#TOC-Excluding-Fields-From-Serialization-and-Deserialization)
-     * [Java Modifier Exclusion](#TOC-Java-Modifier-Exclusion)
-     * [Gson's `@Expose`](#TOC-Gson-s-Expose)
-     * [User Defined Exclusion Strategies](#TOC-User-Defined-Exclusion-Strategies)
-   * [JSON Field Naming Support](#TOC-JSON-Field-Naming-Support)
-   * [Sharing State Across Custom Serializers and Deserializers](#TOC-Sharing-State-Across-Custom-Serializers-and-Deserializers)
-   * [Streaming](#TOC-Streaming)
-6. [Issues in Designing Gson](#TOC-Issues-in-Designing-Gson)
-7. [Future Enhancements to Gson](#TOC-Future-Enhancements-to-Gson)
+1. [Overview](#overview)
+2. [Goals for Gson](#goals-for-gson)
+3. [Gson Performance and Scalability](#gson-performance-and-scalability)
+4. [Gson Users](#gson-users)
+5. [Using Gson](#using-gson)
+   * [Using Gson with Gradle/Android](#using-gson-with-gradleandroid)
+   * [Using Gson with Maven](#using-gson-with-maven)
+   * [Primitives Examples](#primitives-examples)
+   * [Object Examples](#object-examples)
+   * [Finer Points with Objects](#finer-points-with-objects)
+   * [Nested Classes (including Inner Classes)](#nested-classes-including-inner-classes)
+   * [Array Examples](#array-examples)
+   * [Collections Examples](#collections-examples)
+     * [Collections Limitations](#collections-limitations)
+   * [Maps Examples](#maps-examples)
+   * [Serializing and Deserializing Generic Types](#serializing-and-deserializing-generic-types)
+   * [Serializing and Deserializing Collection with Objects of Arbitrary Types](#serializing-and-deserializing-collection-with-objects-of-arbitrary-types)
+   * [Built-in Serializers and Deserializers](#built-in-serializers-and-deserializers)
+   * [Custom Serialization and Deserialization](#custom-serialization-and-deserialization)
+     * [Writing a Serializer](#writing-a-serializer)
+     * [Writing a Deserializer](#writing-a-deserializer)
+   * [Writing an Instance Creator](#writing-an-instance-creator)
+     * [InstanceCreator for a Parameterized Type](#instancecreator-for-a-parameterized-type)
+   * [Compact Vs. Pretty Printing for JSON Output Format](#compact-vs-pretty-printing-for-json-output-format)
+   * [Null Object Support](#null-object-support)
+   * [Versioning Support](#versioning-support)
+   * [Excluding Fields From Serialization and Deserialization](#excluding-fields-from-serialization-and-deserialization)
+     * [Java Modifier Exclusion](#java-modifier-exclusion)
+     * [Gson's `@Expose`](#gsons-expose)
+     * [User Defined Exclusion Strategies](#user-defined-exclusion-strategies)
+   * [JSON Field Naming Support](#json-field-naming-support)
+   * [Sharing State Across Custom Serializers and Deserializers](#sharing-state-across-custom-serializers-and-deserializers)
+   * [Streaming](#streaming)
+6. [Issues in Designing Gson](#issues-in-designing-gson)
+7. [Future Enhancements to Gson](#future-enhancements-to-gson)
 
-## <a name="TOC-Overview"></a>Overview
+## Overview
 
 Gson is a Java library that can be used to convert Java Objects into their JSON representation. It can also be used to convert a JSON string to an equivalent Java object.
 
 Gson can work with arbitrary Java objects including pre-existing objects that you do not have source code of.
 
-## <a name="TOC-Goals-for-Gson"></a>Goals for Gson
+## Goals for Gson
 
 * Provide easy to use mechanisms like `toString()` and constructor (factory method) to convert Java to JSON and vice-versa
 * Allow pre-existing unmodifiable objects to be converted to and from JSON
@@ -50,7 +50,7 @@ Gson can work with arbitrary Java objects including pre-existing objects that yo
 * Support arbitrarily complex objects
 * Generate compact and readable JSON output
 
-## <a name="TOC-Gson-Performance-and-Scalability"></a>Gson Performance and Scalability
+## Gson Performance and Scalability
 
 Here are some metrics that we obtained on a desktop (dual opteron, 8GB RAM, 64-bit Ubuntu) running lots of other things along-with the tests. You can rerun these tests by using the class [`PerformanceTest`](gson/src/test/java/com/google/gson/metrics/PerformanceTest.java).
 
@@ -62,25 +62,25 @@ Here are some metrics that we obtained on a desktop (dual opteron, 8GB RAM, 64-b
 
 Note: Delete the `disabled_` prefix to run these tests. We use this prefix to prevent running these tests every time we run JUnit tests.
 
-## <a name="TOC-Gson-Users"></a>Gson Users
+## Gson Users
 
 Gson was originally created for use inside Google where it is currently used in a number of projects. It is now used by a number of public projects and companies.
 
-## <a name="TOC-Using-Gson"></a>Using Gson
+## Using Gson
 
 The primary class to use is [`Gson`](gson/src/main/java/com/google/gson/Gson.java) which you can just create by calling `new Gson()`. There is also a class [`GsonBuilder`](gson/src/main/java/com/google/gson/GsonBuilder.java) available that can be used to create a Gson instance with various settings like version control and so on.
 
 The Gson instance does not maintain any state while invoking JSON operations. So, you are free to reuse the same object for multiple JSON serialization and deserialization operations.
 
-## <a name="TOC-Gson-With-Gradle"></a>Using Gson with Gradle/Android
+## Using Gson with Gradle/Android
 
 ```gradle
 dependencies {
-    implementation 'com.google.code.gson:gson:2.10'
+    implementation 'com.google.code.gson:gson:2.10.1'
 }
 ```
 
-## <a name="TOC-Gson-With-Maven"></a>Using Gson with Maven
+## Using Gson with Maven
 
 To use Gson with Maven2/3, you can use the Gson version available in Maven Central by adding the following dependency:
 
@@ -90,7 +90,7 @@ To use Gson with Maven2/3, you can use the Gson version available in Maven Centr
     <dependency>
       <groupId>com.google.code.gson</groupId>
       <artifactId>gson</artifactId>
-      <version>2.10</version>
+      <version>2.10.1</version>
       <scope>compile</scope>
     </dependency>
 </dependencies>
@@ -98,7 +98,7 @@ To use Gson with Maven2/3, you can use the Gson version available in Maven Centr
 
 That is it, now your Maven project is Gson enabled.
 
-### <a name="TOC-Primitives-Examples"></a>Primitives Examples
+### Primitives Examples
 
 ```java
 // Serialization
@@ -110,15 +110,15 @@ int[] values = { 1 };
 gson.toJson(values);       // ==> [1]
 
 // Deserialization
-int one = gson.fromJson("1", int.class);
-Integer one = gson.fromJson("1", Integer.class);
-Long one = gson.fromJson("1", Long.class);
-Boolean false = gson.fromJson("false", Boolean.class);
+int i = gson.fromJson("1", int.class);
+Integer intObj = gson.fromJson("1", Integer.class);
+Long longObj = gson.fromJson("1", Long.class);
+Boolean boolObj = gson.fromJson("false", Boolean.class);
 String str = gson.fromJson("\"abc\"", String.class);
-String[] anotherStr = gson.fromJson("[\"abc\"]", String[].class);
+String[] strArray = gson.fromJson("[\"abc\"]", String[].class);
 ```
 
-### <a name="TOC-Object-Examples"></a>Object Examples
+### Object Examples
 
 ```java
 class BagOfPrimitives {
@@ -146,7 +146,7 @@ BagOfPrimitives obj2 = gson.fromJson(json, BagOfPrimitives.class);
 // ==> obj2 is just like obj
 ```
 
-#### <a name="TOC-Finer-Points-with-Objects"></a>**Finer Points with Objects**
+#### **Finer Points with Objects**
 
 * It is perfectly fine (and recommended) to use private fields.
 * There is no need to use any annotations to indicate a field is to be included for serialization and deserialization. All fields in the current class (and from all super classes) are included by default.
@@ -158,7 +158,7 @@ BagOfPrimitives obj2 = gson.fromJson(json, BagOfPrimitives.class);
 * Fields corresponding to the outer classes in inner classes are ignored and not included in serialization or deserialization.
 * Anonymous and local classes are excluded. They will be serialized as JSON `null` and when deserialized their JSON value is ignored and `null` is returned. Convert the classes to `static` nested classes to enable serialization and deserialization for them.
 
-### <a name="TOC-Nested-Classes-including-Inner-Classes-"></a>Nested Classes (including Inner Classes)
+### Nested Classes (including Inner Classes)
 
 Gson can serialize static nested classes quite easily.
 
@@ -197,7 +197,7 @@ public class InstanceCreatorForB implements InstanceCreator<A.B> {
 
 The above is possible, but not recommended.
 
-### <a name="TOC-Array-Examples"></a>Array Examples
+### Array Examples
 
 ```java
 Gson gson = new Gson();
@@ -215,7 +215,7 @@ int[] ints2 = gson.fromJson("[1,2,3,4,5]", int[].class);
 
 We also support multi-dimensional arrays, with arbitrarily complex element types.
 
-### <a name="TOC-Collections-Examples"></a>Collections Examples
+### Collections Examples
 
 ```java
 Gson gson = new Gson();
@@ -235,12 +235,12 @@ Collection<Integer> ints2 = gson.fromJson(json, collectionType);
 Fairly hideous: note how we define the type of collection.
 Unfortunately, there is no way to get around this in Java.
 
-#### <a name="TOC-Collections-Limitations"></a>Collections Limitations
+#### Collections Limitations
 
 Gson can serialize collection of arbitrary objects but can not deserialize from it, because there is no way for the user to indicate the type of the resulting object. Instead, while deserializing, the Collection must be of a specific, generic type.
 This makes sense, and is rarely a problem when following good Java coding practices.
 
-### <a name="TOC-Maps-Examples"></a>Maps Examples
+### Maps Examples
 
 Gson by default serializes any `java.util.Map` implementation as a JSON object. Because JSON objects only support strings as member names, Gson converts the Map keys to strings by calling `toString()` on them, and using `"null"` for `null` keys:
 
@@ -309,7 +309,7 @@ String json = gson.toJson(stringMap); // json is {"key":"value"}
 
 Note that when deserializing enums as Map keys, if Gson is unable to find an enum constant with a matching `name()` value respectively `@SerializedName` annotation, it falls back to looking up the enum constant by its `toString()` value. This is to work around the issue described above, but only applies to enum constants.
 
-### <a name="TOC-Serializing-and-Deserializing-Generic-Types"></a>Serializing and Deserializing Generic Types
+### Serializing and Deserializing Generic Types
 
 When you call `toJson(obj)`, Gson calls `obj.getClass()` to get information on the fields to serialize. Similarly, you can typically pass `MyClass.class` object in the `fromJson(json, MyClass.class)` method. This works fine if the object is a non-generic type. However, if the object is of a generic type, then the Generic type information is lost because of Java Type Erasure. Here is an example illustrating the point:
 
@@ -337,7 +337,7 @@ gson.fromJson(json, fooType);
 
 The idiom used to get `fooType` actually defines an anonymous local inner class containing a method `getType()` that returns the fully parameterized type.
 
-### <a name="TOC-Serializing-and-Deserializing-Collection-with-Objects-of-Arbitrary-Types"></a>Serializing and Deserializing Collection with Objects of Arbitrary Types
+### Serializing and Deserializing Collection with Objects of Arbitrary Types
 
 Sometimes you are dealing with JSON array that contains mixed types. For example:
 `['hello',5,{name:'GREETINGS',source:'guest'}]`
@@ -376,7 +376,7 @@ However, deserialization with `fromJson(json, Collection.class)` will not work s
 
 This approach is practical only if the array appears as a top-level element or if you can change the field type holding the collection to be of type `Collection<MyCollectionMemberType>`.
 
-### <a name="TOC-Built-in-Serializers-and-Deserializers"></a>Built-in Serializers and Deserializers
+### Built-in Serializers and Deserializers
 
 Gson has built-in serializers and deserializers for commonly used classes whose default representation may be inappropriate, for instance
 
@@ -387,7 +387,7 @@ For many more, see the internal class [`TypeAdapters`](gson/src/main/java/com/go
 
 You can also find source code for some commonly used classes such as JodaTime at [this page](https://sites.google.com/site/gson/gson-type-adapters-for-common-classes-1).
 
-### <a name="TOC-Custom-Serialization-and-Deserialization"></a>Custom Serialization and Deserialization
+### Custom Serialization and Deserialization
 
 Sometimes default representation is not what you want. This is often the case when dealing with library classes (DateTime, etc).
 Gson allows you to register your own custom serializers and deserializers. This is done by defining two parts:
@@ -407,7 +407,7 @@ gson.registerTypeAdapter(MyType.class, new MyInstanceCreator());
 
 `registerTypeAdapter` call checks if the type adapter implements more than one of these interfaces and register it for all of them.
 
-#### <a name="TOC-Writing-a-Serializer"></a>Writing a Serializer
+#### Writing a Serializer
 
 Here is an example of how to write a custom serializer for JodaTime `DateTime` class.
 
@@ -421,7 +421,7 @@ private class DateTimeSerializer implements JsonSerializer<DateTime> {
 
 Gson calls `serialize()` when it runs into a `DateTime` object during serialization.
 
-#### <a name="TOC-Writing-a-Deserializer"></a>Writing a Deserializer
+#### Writing a Deserializer
 
 Here is an example of how to write a custom deserializer for JodaTime DateTime class.
 
@@ -449,7 +449,7 @@ Often you want to register a single handler for all generic types corresponding
 Gson supports registering a single handler for this. You can also register a specific handler for a specific generic type (say `Id<RequiresSpecialHandling>` needed special handling).
 The `Type` parameter for the `toJson()` and `fromJson()` contains the generic type information to help you write a single handler for all generic types corresponding to the same raw type.
 
-### <a name="TOC-Writing-an-Instance-Creator"></a>Writing an Instance Creator
+### Writing an Instance Creator
 
 While deserializing an Object, Gson needs to create a default instance of the class.
 Well-behaved classes that are meant for serialization and deserialization should have a no-argument constructor.
@@ -473,7 +473,7 @@ Type could be of a corresponding generic type
 * Very useful to invoke constructors which need specific generic type information
 * For example, if the `Id` class stores the class for which the Id is being created
 
-#### <a name="TOC-InstanceCreator-for-a-Parameterized-Type"></a>InstanceCreator for a Parameterized Type
+#### InstanceCreator for a Parameterized Type
 
 Sometimes the type that you are trying to instantiate is a parameterized type. Generally, this is not a problem since the actual instance is of raw type. Here is an example:
 
@@ -482,7 +482,7 @@ class MyList<T> extends ArrayList<T> {
 }
 
 class MyListInstanceCreator implements InstanceCreator<MyList<?>> {
-    @SuppressWarnings("unchecked")
+  @SuppressWarnings("unchecked")
   public MyList<?> createInstance(Type type) {
     // No need to use a parameterized list since the actual instance will have the raw type anyway.
     return new MyList();
@@ -513,9 +513,9 @@ class IdInstanceCreator implements InstanceCreator<Id<?>> {
 
 In the above example, an instance of the Id class can not be created without actually passing in the actual type for the parameterized type. We solve this problem by using the passed method parameter, `type`. The `type` object in this case is the Java parameterized type representation of `Id<Foo>` where the actual instance should be bound to `Id<Foo>`. Since `Id` class has just one parameterized type parameter, `T`, we use the zeroth element of the type array returned by `getActualTypeArgument()` which will hold `Foo.class` in this case.
 
-### <a name="TOC-Compact-Vs.-Pretty-Printing-for-JSON-Output-Format"></a>Compact Vs. Pretty Printing for JSON Output Format
+### Compact Vs. Pretty Printing for JSON Output Format
 
-The default JSON output that is provided by Gson is a compact JSON format. This means that there will not be any whitespace in the output JSON structure. Therefore, there will be no whitespace between field names and its value, object fields, and objects within arrays in the JSON output. As well, "null" fields will be ignored in the output (NOTE: null values will still be included in collections/arrays of objects). See the [Null Object Support](#TOC-Null-Object-Support) section for information on configure Gson to output all null values.
+The default JSON output that is provided by Gson is a compact JSON format. This means that there will not be any whitespace in the output JSON structure. Therefore, there will be no whitespace between field names and its value, object fields, and objects within arrays in the JSON output. As well, "null" fields will be ignored in the output (NOTE: null values will still be included in collections/arrays of objects). See the [Null Object Support](#null-object-support) section for information on configure Gson to output all null values.
 
 If you would like to use the Pretty Print feature, you must configure your `Gson` instance using the `GsonBuilder`. The `JsonFormatter` is not exposed through our public API, so the client is unable to configure the default print settings/margins for the JSON output. For now, we only provide a default `JsonPrintFormatter` that has default line length of 80 character, 2 character indentation, and 4 character right margin.
 
@@ -526,7 +526,7 @@ Gson gson = new GsonBuilder().setPrettyPrinting().create();
 String jsonOutput = gson.toJson(someObject);
 ```
 
-### <a name="TOC-Null-Object-Support"></a>Null Object Support
+### Null Object Support
 
 The default behaviour that is implemented in Gson is that `null` object fields are ignored. This allows for a more compact output format; however, the client must define a default value for these fields as the JSON format is converted back into its Java form.
 
@@ -566,12 +566,12 @@ System.out.println(json);
 
 The output is:
 
-```
+```json
 {"s":null,"i":5}
 null
 ```
 
-### <a name="TOC-Versioning-Support"></a>Versioning Support
+### Versioning Support
 
 Multiple versions of the same object can be maintained by using [@Since](gson/src/main/java/com/google/gson/annotations/Since.java) annotation. This annotation can be used on Classes, Fields and, in a future release, Methods. In order to leverage this feature, you must configure your `Gson` instance to ignore any field/object that is greater than some version number. If no version is set on the `Gson` instance then it will serialize and deserialize all fields and classes regardless of the version.
 
@@ -601,17 +601,17 @@ System.out.println(jsonOutput);
 
 The output is:
 
-```
+```json
 {"newField":"new","field":"old"}
 
 {"newerField":"newer","newField":"new","field":"old"}
 ```
 
-### <a name="TOC-Excluding-Fields-From-Serialization-and-Deserialization"></a>Excluding Fields From Serialization and Deserialization
+### Excluding Fields From Serialization and Deserialization
 
-Gson supports numerous mechanisms for excluding top-level classes, fields and field types. Below are pluggable mechanisms that allow field and class exclusion. If none of the below mechanisms satisfy your needs then you can always use [custom serializers and deserializers](#TOC-Custom-Serialization-and-Deserialization).
+Gson supports numerous mechanisms for excluding top-level classes, fields and field types. Below are pluggable mechanisms that allow field and class exclusion. If none of the below mechanisms satisfy your needs then you can always use [custom serializers and deserializers](#custom-serialization-and-deserialization).
 
-#### <a name="TOC-Java-Modifier-Exclusion"></a>Java Modifier Exclusion
+#### Java Modifier Exclusion
 
 By default, if you mark a field as `transient`, it will be excluded. As well, if a field is marked as `static` then by default it will be excluded. If you want to include some transient fields then you can do the following:
 
@@ -630,11 +630,11 @@ Gson gson = new GsonBuilder()
     .create();
 ```
 
-#### <a name="TOC-Gson-s-Expose"></a>Gson's `@Expose`
+#### Gson's `@Expose`
 
 This feature provides a way where you can mark certain fields of your objects to be excluded for consideration for serialization and deserialization to JSON. To use this annotation, you must create Gson by using `new GsonBuilder().excludeFieldsWithoutExposeAnnotation().create()`. The Gson instance created will exclude all fields in a class that are not marked with `@Expose` annotation.
 
-#### <a name="TOC-User-Defined-Exclusion-Strategies"></a>User Defined Exclusion Strategies
+#### User Defined Exclusion Strategies
 
 If the above mechanisms for excluding fields and class type do not work for you then you can always write your own exclusion strategy and plug it into Gson. See the [`ExclusionStrategy`](https://javadoc.io/doc/com.google.code.gson/gson/latest/com.google.gson/com/google/gson/ExclusionStrategy.html) JavaDoc for more information.
 
@@ -693,7 +693,7 @@ The output is:
 {"longField":1234}
 ```
 
-### <a name="TOC-JSON-Field-Naming-Support"></a>JSON Field Naming Support
+### JSON Field Naming Support
 
 Gson supports some pre-defined field naming policies to convert the standard Java field names (i.e., camel cased names starting with lower case --- `sampleFieldNameInJava`) to a JSON field name (i.e., `sample_field_name_in_java` or `SampleFieldNameInJava`). See the [FieldNamingPolicy](https://javadoc.io/doc/com.google.code.gson/gson/latest/com.google.gson/com/google/gson/FieldNamingPolicy.html) class for information on the pre-defined naming policies.
 
@@ -726,7 +726,7 @@ The output is:
 
 If you have a need for custom naming policy ([see this discussion](https://groups.google.com/group/google-gson/browse_thread/thread/cb441a2d717f6892)), you can use the [@SerializedName](https://javadoc.io/doc/com.google.code.gson/gson/latest/com.google.gson/com/google/gson/annotations/SerializedName.html) annotation.
 
-### <a name="TOC-Sharing-State-Across-Custom-Serializers-and-Deserializers"></a>Sharing State Across Custom Serializers and Deserializers
+### Sharing State Across Custom Serializers and Deserializers
 
 Sometimes you need to share state across custom serializers/deserializers ([see this discussion](https://groups.google.com/group/google-gson/browse_thread/thread/2850010691ea09fb)). You can use the following three strategies to accomplish this:
 
@@ -736,14 +736,14 @@ Sometimes you need to share state across custom serializers/deserializers ([see
 
 1 and 2 are not thread-safe options, but 3 is.
 
-### <a name="TOC-Streaming"></a>Streaming
+### Streaming
 
 In addition Gson's object model and data binding, you can use Gson to read from and write to a [stream](https://sites.google.com/site/gson/streaming). You can also combine streaming and object model access to get the best of both approaches.
 
-## <a name="TOC-Issues-in-Designing-Gson"></a>Issues in Designing Gson
+## Issues in Designing Gson
 
 See the [Gson design document](GsonDesignDocument.md "Gson design document") for a discussion of issues we faced while designing Gson. It also include a comparison of Gson with other Java libraries that can be used for JSON conversion.
 
-## <a name="TOC-Future-Enhancements-to-Gson"></a>Future Enhancements to Gson
+## Future Enhancements to Gson
 
 For the latest list of proposed enhancements or if you'd like to suggest new ones, see the [Issues section](https://github.com/google/gson/issues) under the project website.
diff --git a/gson/pom.xml b/gson/pom.xml
index 745d72b6..944e55dd 100644
--- a/gson/pom.xml
+++ b/gson/pom.xml
@@ -4,7 +4,7 @@
   <parent>
     <groupId>io.gitlab.jfronny</groupId>
     <artifactId>gson-parent</artifactId>
-    <version>2.11.0-SNAPSHOT</version>
+    <version>2.10.2-SNAPSHOT</version>
   </parent>
 
   <artifactId>gson</artifactId>
@@ -23,6 +23,12 @@
       <artifactId>junit</artifactId>
       <scope>test</scope>
     </dependency>
+    <dependency>
+      <groupId>com.google.truth</groupId>
+      <artifactId>truth</artifactId>
+      <version>1.1.3</version>
+      <scope>test</scope>
+    </dependency>
   </dependencies>
 
   <build>
@@ -81,7 +87,7 @@
       <plugin>
         <groupId>biz.aQute.bnd</groupId>
         <artifactId>bnd-maven-plugin</artifactId>
-        <version>6.3.1</version>
+        <version>6.4.0</version>
         <executions>
           <execution>
             <goals>
@@ -97,7 +103,7 @@
       <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-surefire-plugin</artifactId>
-        <version>3.0.0-M7</version>
+        <version>3.0.0-M8</version>
         <configuration>
           <!-- Deny illegal access, this is required for ReflectionAccessTest -->
           <!-- Requires Java >= 9; Important: In case future Java versions 
diff --git a/gson/src/main/java/com/google/gson/Gson.java b/gson/src/main/java/com/google/gson/Gson.java
index b9638d27..0a905efa 100644
--- a/gson/src/main/java/com/google/gson/Gson.java
+++ b/gson/src/main/java/com/google/gson/Gson.java
@@ -135,14 +135,18 @@ import java.util.concurrent.atomic.AtomicLongArray;
  */
 public final class Gson {
   /**
-   * This thread local guards against reentrant calls to getAdapter(). In
-   * certain object graphs, creating an adapter for a type may recursively
+   * This thread local guards against reentrant calls to {@link #getAdapter(TypeToken)}.
+   * In certain object graphs, creating an adapter for a type may recursively
    * require an adapter for the same type! Without intervention, the recursive
-   * lookup would stack overflow. We cheat by returning a proxy type adapter.
-   * The proxy is wired up once the initial adapter has been created.
+   * lookup would stack overflow. We cheat by returning a proxy type adapter,
+   * {@link FutureTypeAdapter}, which is wired up once the initial adapter has
+   * been created.
+   *
+   * <p>The map stores the type adapters for ongoing {@code getAdapter} calls,
+   * with the type token provided to {@code getAdapter} as key and either
+   * {@code FutureTypeAdapter} or a regular {@code TypeAdapter} as value.
    */
-  private final ThreadLocal<Map<TypeToken<?>, FutureTypeAdapter<?>>> calls
-      = new ThreadLocal<>();
+  private final ThreadLocal<Map<TypeToken<?>, TypeAdapter<?>>> threadLocalAdapterResults = new ThreadLocal<>();
 
   private final ConcurrentMap<TypeToken<?>, TypeAdapter<?>> typeTokenCache = new ConcurrentHashMap<>();
 
@@ -484,9 +488,14 @@ public final class Gson {
   }
 
   /**
-   * Returns the type adapter for {@code} type.
+   * Returns the type adapter for {@code type}.
    *
-   * @throws IllegalArgumentException if this GSON cannot serialize and
+   * <p>When calling this method concurrently from multiple threads and requesting
+   * an adapter for the same type this method may return different {@code TypeAdapter}
+   * instances. However, that should normally not be an issue because {@code TypeAdapter}
+   * implementations are supposed to be stateless.
+   *
+   * @throws IllegalArgumentException if this Gson instance cannot serialize and
    *     deserialize {@code type}.
    */
   public <T> TypeAdapter<T> getAdapter(TypeToken<T> type) {
@@ -498,47 +507,55 @@ public final class Gson {
       return adapter;
     }
 
-    Map<TypeToken<?>, FutureTypeAdapter<?>> threadCalls = calls.get();
-    boolean requiresThreadLocalCleanup = false;
+    Map<TypeToken<?>, TypeAdapter<?>> threadCalls = threadLocalAdapterResults.get();
+    boolean isInitialAdapterRequest = false;
     if (threadCalls == null) {
       threadCalls = new HashMap<>();
-      calls.set(threadCalls);
-      requiresThreadLocalCleanup = true;
-    }
-
-    // the key and value type parameters always agree
-    @SuppressWarnings("unchecked")
-    FutureTypeAdapter<T> ongoingCall = (FutureTypeAdapter<T>) threadCalls.get(type);
-    if (ongoingCall != null) {
-      return ongoingCall;
+      threadLocalAdapterResults.set(threadCalls);
+      isInitialAdapterRequest = true;
+    } else {
+      // the key and value type parameters always agree
+      @SuppressWarnings("unchecked")
+      TypeAdapter<T> ongoingCall = (TypeAdapter<T>) threadCalls.get(type);
+      if (ongoingCall != null) {
+        return ongoingCall;
+      }
     }
 
+    TypeAdapter<T> candidate = null;
     try {
       FutureTypeAdapter<T> call = new FutureTypeAdapter<>();
       threadCalls.put(type, call);
 
       for (TypeAdapterFactory factory : factories) {
-        TypeAdapter<T> candidate = factory.create(this, type);
+        candidate = factory.create(this, type);
         if (candidate != null) {
-          @SuppressWarnings("unchecked")
-          TypeAdapter<T> existingAdapter = (TypeAdapter<T>) typeTokenCache.putIfAbsent(type, candidate);
-          // If other thread concurrently added adapter prefer that one instead
-          if (existingAdapter != null) {
-            candidate = existingAdapter;
-          }
-
           call.setDelegate(candidate);
-          return candidate;
+          // Replace future adapter with actual adapter
+          threadCalls.put(type, candidate);
+          break;
         }
       }
-      throw new IllegalArgumentException("GSON (" + GsonBuildConfig.VERSION + ") cannot handle " + type);
     } finally {
-      threadCalls.remove(type);
-
-      if (requiresThreadLocalCleanup) {
-        calls.remove();
+      if (isInitialAdapterRequest) {
+        threadLocalAdapterResults.remove();
       }
     }
+
+    if (candidate == null) {
+      throw new IllegalArgumentException("GSON (" + GsonBuildConfig.VERSION + ") cannot handle " + type);
+    }
+
+    if (isInitialAdapterRequest) {
+      /*
+       * Publish resolved adapters to all threads
+       * Can only do this for the initial request because cyclic dependency TypeA -> TypeB -> TypeA
+       * would otherwise publish adapter for TypeB which uses not yet resolved adapter for TypeA
+       * See https://github.com/google/gson/issues/625
+       */
+      typeTokenCache.putAll(threadCalls);
+    }
+    return candidate;
   }
 
   /**
@@ -616,9 +633,9 @@ public final class Gson {
   }
 
   /**
-   * Returns the type adapter for {@code} type.
+   * Returns the type adapter for {@code type}.
    *
-   * @throws IllegalArgumentException if this GSON cannot serialize and
+   * @throws IllegalArgumentException if this Gson instance cannot serialize and
    *     deserialize {@code type}.
    */
   public <T> TypeAdapter<T> getAdapter(Class<T> type) {
@@ -803,9 +820,7 @@ public final class Gson {
     } catch (IOException e) {
       throw new JsonIOException(e);
     } catch (AssertionError e) {
-      AssertionError error = new AssertionError("AssertionError (GSON " + GsonBuildConfig.VERSION + "): " + e.getMessage());
-      error.initCause(e);
-      throw error;
+      throw new AssertionError("AssertionError (GSON " + GsonBuildConfig.VERSION + "): " + e.getMessage(), e);
     } finally {
       writer.setLenient(oldLenient);
       writer.setOmitQuotes(oldOmitQuotes);
@@ -915,9 +930,7 @@ public final class Gson {
     } catch (IOException e) {
       throw new JsonIOException(e);
     } catch (AssertionError e) {
-      AssertionError error = new AssertionError("AssertionError (GSON " + GsonBuildConfig.VERSION + "): " + e.getMessage());
-      error.initCause(e);
-      throw error;
+      throw new AssertionError("AssertionError (GSON " + GsonBuildConfig.VERSION + "): " + e.getMessage(), e);
     } finally {
       writer.setLenient(oldLenient);
       writer.setOmitQuotes(oldOmitQuotes);
@@ -1196,8 +1209,7 @@ public final class Gson {
       reader.peek();
       isEmpty = false;
       TypeAdapter<T> typeAdapter = getAdapter(typeOfT);
-      T object = typeAdapter.read(reader);
-      return object;
+      return typeAdapter.read(reader);
     } catch (EOFException e) {
       /*
        * For compatibility with JSON 1.5 and earlier, we return null for empty
@@ -1213,9 +1225,7 @@ public final class Gson {
       // TODO(inder): Figure out whether it is indeed right to rethrow this as JsonSyntaxException
       throw new JsonSyntaxException(e);
     } catch (AssertionError e) {
-      AssertionError error = new AssertionError("AssertionError (GSON " + GsonBuildConfig.VERSION + "): " + e.getMessage());
-      error.initCause(e);
-      throw error;
+      throw new AssertionError("AssertionError (GSON " + GsonBuildConfig.VERSION + "): " + e.getMessage(), e);
     } finally {
       reader.setLenient(oldLenient);
     }
@@ -1304,19 +1314,32 @@ public final class Gson {
     return fromJson(new JsonTreeReader(json), typeOfT);
   }
 
+  /**
+   * Proxy type adapter for cyclic type graphs.
+   *
+   * <p><b>Important:</b> Setting the delegate adapter is not thread-safe; instances of
+   * {@code FutureTypeAdapter} must only be published to other threads after the delegate
+   * has been set.
+   *
+   * @see Gson#threadLocalAdapterResults
+   */
   static class FutureTypeAdapter<T> extends SerializationDelegatingTypeAdapter<T> {
-    private TypeAdapter<T> delegate;
+    private TypeAdapter<T> delegate = null;
 
     public void setDelegate(TypeAdapter<T> typeAdapter) {
       if (delegate != null) {
-        throw new AssertionError();
+        throw new AssertionError("Delegate is already set");
       }
       delegate = typeAdapter;
     }
 
     private TypeAdapter<T> delegate() {
+      TypeAdapter<T> delegate = this.delegate;
       if (delegate == null) {
-        throw new IllegalStateException("Delegate has not been set yet");
+        // Can occur when adapter is leaked to other thread or when adapter is used for (de-)serialization
+        // directly within the TypeAdapterFactory which requested it
+        throw new IllegalStateException("Adapter for type with cyclic dependency has been used"
+            + " before dependency has been resolved");
       }
       return delegate;
     }
@@ -1336,11 +1359,9 @@ public final class Gson {
 
   @Override
   public String toString() {
-    return new StringBuilder("{serializeNulls:")
-        .append(serializeNulls)
-        .append(",factories:").append(factories)
-        .append(",instanceCreators:").append(constructorConstructor)
-        .append("}")
-        .toString();
+    return "{serializeNulls:" + serializeNulls
+        + ",factories:" + factories
+        + ",instanceCreators:" + constructorConstructor
+        + "}";
   }
 }
diff --git a/gson/src/main/java/com/google/gson/JsonDeserializer.java b/gson/src/main/java/com/google/gson/JsonDeserializer.java
index 6462d45c..ca797eee 100644
--- a/gson/src/main/java/com/google/gson/JsonDeserializer.java
+++ b/gson/src/main/java/com/google/gson/JsonDeserializer.java
@@ -63,6 +63,9 @@ import java.lang.reflect.Type;
  * Gson gson = new GsonBuilder().registerTypeAdapter(Id.class, new IdDeserializer()).create();
  * </pre>
  *
+ * <p>Deserializers should be stateless and thread-safe, otherwise the thread-safety
+ * guarantees of {@link Gson} might not apply.
+ *
  * <p>New applications should prefer {@link TypeAdapter}, whose streaming API
  * is more efficient than this interface's tree API.
  *
@@ -80,7 +83,7 @@ public interface JsonDeserializer<T> {
    * <p>In the implementation of this call-back method, you should consider invoking
    * {@link JsonDeserializationContext#deserialize(JsonElement, Type)} method to create objects
    * for any non-trivial field of the returned object. However, you should never invoke it on the
-   * the same type passing {@code json} since that will cause an infinite loop (Gson will call your
+   * same type passing {@code json} since that will cause an infinite loop (Gson will call your
    * call-back method again).
    *
    * @param json The Json data being deserialized
diff --git a/gson/src/main/java/com/google/gson/JsonNull.java b/gson/src/main/java/com/google/gson/JsonNull.java
index b14fd3f1..1a4c136c 100644
--- a/gson/src/main/java/com/google/gson/JsonNull.java
+++ b/gson/src/main/java/com/google/gson/JsonNull.java
@@ -64,6 +64,6 @@ public final class JsonNull extends JsonElement {
    */
   @Override
   public boolean equals(Object other) {
-    return this == other || other instanceof JsonNull;
+    return other instanceof JsonNull;
   }
 }
diff --git a/gson/src/main/java/com/google/gson/JsonObject.java b/gson/src/main/java/com/google/gson/JsonObject.java
index fdf240d2..ac8ad685 100644
--- a/gson/src/main/java/com/google/gson/JsonObject.java
+++ b/gson/src/main/java/com/google/gson/JsonObject.java
@@ -159,7 +159,7 @@ public final class JsonObject extends JsonElement {
    * Returns true if the number of key/value pairs in the object is zero.
    *
    * @return true if the number of key/value pairs in the object is zero.
-   * @since $next-version$
+   * @since 2.10.1
    */
   public boolean isEmpty() {
     return members.size() == 0;
diff --git a/gson/src/main/java/com/google/gson/JsonPrimitive.java b/gson/src/main/java/com/google/gson/JsonPrimitive.java
index 92a8df15..66dacfe5 100644
--- a/gson/src/main/java/com/google/gson/JsonPrimitive.java
+++ b/gson/src/main/java/com/google/gson/JsonPrimitive.java
@@ -104,7 +104,7 @@ public final class JsonPrimitive extends JsonElement {
   @Override
   public boolean getAsBoolean() {
     if (isBoolean()) {
-      return ((Boolean) value).booleanValue();
+      return (Boolean) value;
     }
 	// Check to see if the value as a String is "true" in any case.
     return Boolean.parseBoolean(getAsString());
diff --git a/gson/src/main/java/com/google/gson/JsonSerializer.java b/gson/src/main/java/com/google/gson/JsonSerializer.java
index 2bdb8fb2..01d62723 100644
--- a/gson/src/main/java/com/google/gson/JsonSerializer.java
+++ b/gson/src/main/java/com/google/gson/JsonSerializer.java
@@ -60,6 +60,9 @@ import java.lang.reflect.Type;
  * Gson gson = new GsonBuilder().registerTypeAdapter(Id.class, new IdSerializer()).create();
  * </pre>
  *
+ * <p>Serializers should be stateless and thread-safe, otherwise the thread-safety
+ * guarantees of {@link Gson} might not apply.
+ *
  * <p>New applications should prefer {@link TypeAdapter}, whose streaming API
  * is more efficient than this interface's tree API.
  *
diff --git a/gson/src/main/java/com/google/gson/JsonStreamParser.java b/gson/src/main/java/com/google/gson/JsonStreamParser.java
index 27597da6..2bd86ac5 100644
--- a/gson/src/main/java/com/google/gson/JsonStreamParser.java
+++ b/gson/src/main/java/com/google/gson/JsonStreamParser.java
@@ -15,18 +15,16 @@
  */
 package com.google.gson;
 
-import java.io.EOFException;
+import com.google.gson.internal.Streams;
+import com.google.gson.stream.JsonReader;
+import com.google.gson.stream.JsonToken;
+import com.google.gson.stream.MalformedJsonException;
 import java.io.IOException;
 import java.io.Reader;
 import java.io.StringReader;
 import java.util.Iterator;
 import java.util.NoSuchElementException;
 
-import com.google.gson.internal.Streams;
-import com.google.gson.stream.JsonReader;
-import com.google.gson.stream.JsonToken;
-import com.google.gson.stream.MalformedJsonException;
-
 /**
  * A streaming parser that allows reading of multiple {@link JsonElement}s from the specified reader
  * asynchronously. The JSON data is parsed in lenient mode, see also
@@ -61,7 +59,7 @@ public final class JsonStreamParser implements Iterator<JsonElement> {
   public JsonStreamParser(String json) {
     this(new StringReader(json));
   }
-  
+
   /**
    * @param reader The data stream containing JSON elements concatenated to each other.
    * @since 1.4
@@ -71,13 +69,13 @@ public final class JsonStreamParser implements Iterator<JsonElement> {
     parser.setLenient(true);
     lock = new Object();
   }
-  
+
   /**
    * Returns the next available {@link JsonElement} on the reader. Throws a
    * {@link NoSuchElementException} if no element is available.
    *
    * @return the next available {@code JsonElement} on the reader.
-   * @throws JsonSyntaxException if the incoming stream is malformed JSON.
+   * @throws JsonParseException if the incoming stream is malformed JSON.
    * @throws NoSuchElementException if no {@code JsonElement} is available.
    * @since 1.4
    */
@@ -86,22 +84,20 @@ public final class JsonStreamParser implements Iterator<JsonElement> {
     if (!hasNext()) {
       throw new NoSuchElementException();
     }
-    
+
     try {
       return Streams.parse(parser);
     } catch (StackOverflowError e) {
       throw new JsonParseException("Failed parsing JSON source to Json", e);
     } catch (OutOfMemoryError e) {
       throw new JsonParseException("Failed parsing JSON source to Json", e);
-    } catch (JsonParseException e) {
-      throw e.getCause() instanceof EOFException ? new NoSuchElementException() : e;
     }
   }
 
   /**
    * Returns true if a {@link JsonElement} is available on the input for consumption
    * @return true if a {@link JsonElement} is available on the input, false otherwise
-   * @throws JsonSyntaxException if the incoming stream is malformed JSON.
+   * @throws JsonParseException if the incoming stream is malformed JSON.
    * @since 1.4
    */
   @Override
diff --git a/gson/src/main/java/com/google/gson/TypeAdapter.java b/gson/src/main/java/com/google/gson/TypeAdapter.java
index 98e1668a..5fdea225 100644
--- a/gson/src/main/java/com/google/gson/TypeAdapter.java
+++ b/gson/src/main/java/com/google/gson/TypeAdapter.java
@@ -81,6 +81,9 @@ import java.io.Writer;
  * when writing to a JSON object) will be omitted automatically. In either case
  * your type adapter must handle null.
  *
+ * <p>Type adapters should be stateless and thread-safe, otherwise the thread-safety
+ * guarantees of {@link Gson} might not apply.
+ *
  * <p>To use a custom type adapter with Gson, you must <i>register</i> it with a
  * {@link GsonBuilder}: <pre>   {@code
  *
diff --git a/gson/src/main/java/com/google/gson/internal/$Gson$Types.java b/gson/src/main/java/com/google/gson/internal/$Gson$Types.java
index 965e010f..4a925aa4 100644
--- a/gson/src/main/java/com/google/gson/internal/$Gson$Types.java
+++ b/gson/src/main/java/com/google/gson/internal/$Gson$Types.java
@@ -34,6 +34,7 @@ import java.util.HashMap;
 import java.util.Map;
 import java.util.NoSuchElementException;
 import java.util.Properties;
+import java.util.Objects;
 
 /**
  * Static methods for working with types.
@@ -167,7 +168,7 @@ public final class $Gson$Types {
   }
 
   private static boolean equal(Object a, Object b) {
-    return a == b || (a != null && a.equals(b));
+    return Objects.equals(a, b);
   }
 
   /**
diff --git a/gson/src/main/java/com/google/gson/internal/Excluder.java b/gson/src/main/java/com/google/gson/internal/Excluder.java
index 03bd45cb..dd167b48 100644
--- a/gson/src/main/java/com/google/gson/internal/Excluder.java
+++ b/gson/src/main/java/com/google/gson/internal/Excluder.java
@@ -198,11 +198,7 @@ public final class Excluder implements TypeAdapterFactory, Cloneable {
           return true;
       }
 
-      if (isAnonymousOrNonStaticLocal(clazz)) {
-          return true;
-      }
-
-      return false;
+      return isAnonymousOrNonStaticLocal(clazz);
   }
 
   public boolean excludeClass(Class<?> clazz, boolean serialize) {
diff --git a/gson/src/main/java/com/google/gson/internal/LinkedTreeMap.java b/gson/src/main/java/com/google/gson/internal/LinkedTreeMap.java
index e47e165d..1fe512ad 100644
--- a/gson/src/main/java/com/google/gson/internal/LinkedTreeMap.java
+++ b/gson/src/main/java/com/google/gson/internal/LinkedTreeMap.java
@@ -30,6 +30,7 @@ import java.util.Iterator;
 import java.util.LinkedHashMap;
 import java.util.NoSuchElementException;
 import java.util.Set;
+import java.util.Objects;
 
 /**
  * A map of comparable keys to values. Unlike {@code TreeMap}, this class uses
@@ -227,7 +228,7 @@ public final class LinkedTreeMap<K, V> extends AbstractMap<K, V> implements Seri
   }
 
   private boolean equal(Object a, Object b) {
-    return a == b || (a != null && a.equals(b));
+    return Objects.equals(a, b);
   }
 
   /**
diff --git a/gson/src/main/java/com/google/gson/internal/bind/DefaultDateTypeAdapter.java b/gson/src/main/java/com/google/gson/internal/bind/DefaultDateTypeAdapter.java
index 4719ea15..9e578bf4 100644
--- a/gson/src/main/java/com/google/gson/internal/bind/DefaultDateTypeAdapter.java
+++ b/gson/src/main/java/com/google/gson/internal/bind/DefaultDateTypeAdapter.java
@@ -62,7 +62,7 @@ public final class DefaultDateTypeAdapter<T extends Date> extends TypeAdapter<T>
 
     protected abstract T deserialize(Date date);
 
-    private final TypeAdapterFactory createFactory(DefaultDateTypeAdapter<T> adapter) {
+    private TypeAdapterFactory createFactory(DefaultDateTypeAdapter<T> adapter) {
       return TypeAdapters.newFactory(dateClass, adapter);
     }
 
diff --git a/gson/src/main/java/com/google/gson/internal/bind/JsonTreeReader.java b/gson/src/main/java/com/google/gson/internal/bind/JsonTreeReader.java
index 88e654c8..01e91826 100644
--- a/gson/src/main/java/com/google/gson/internal/bind/JsonTreeReader.java
+++ b/gson/src/main/java/com/google/gson/internal/bind/JsonTreeReader.java
@@ -38,10 +38,10 @@ import java.util.Map;
  */
 public final class JsonTreeReader extends JsonReader {
   private static final Reader UNREADABLE_READER = new Reader() {
-    @Override public int read(char[] buffer, int offset, int count) throws IOException {
+    @Override public int read(char[] buffer, int offset, int count) {
       throw new AssertionError();
     }
-    @Override public void close() throws IOException {
+    @Override public void close() {
       throw new AssertionError();
     }
   };
diff --git a/gson/src/main/java/com/google/gson/internal/bind/JsonTreeWriter.java b/gson/src/main/java/com/google/gson/internal/bind/JsonTreeWriter.java
index 5363a6bc..35f3b680 100644
--- a/gson/src/main/java/com/google/gson/internal/bind/JsonTreeWriter.java
+++ b/gson/src/main/java/com/google/gson/internal/bind/JsonTreeWriter.java
@@ -36,10 +36,10 @@ public final class JsonTreeWriter extends JsonWriter {
     @Override public void write(char[] buffer, int offset, int counter) {
       throw new AssertionError();
     }
-    @Override public void flush() throws IOException {
+    @Override public void flush() {
       throw new AssertionError();
     }
-    @Override public void close() throws IOException {
+    @Override public void close() {
       throw new AssertionError();
     }
   };
diff --git a/gson/src/main/java/com/google/gson/internal/bind/ReflectiveTypeAdapterFactory.java b/gson/src/main/java/com/google/gson/internal/bind/ReflectiveTypeAdapterFactory.java
index 5ddac50e..4db9bd72 100644
--- a/gson/src/main/java/com/google/gson/internal/bind/ReflectiveTypeAdapterFactory.java
+++ b/gson/src/main/java/com/google/gson/internal/bind/ReflectiveTypeAdapterFactory.java
@@ -139,7 +139,7 @@ public final class ReflectiveTypeAdapterFactory implements TypeAdapterFactory {
     }
   }
 
-  private ReflectiveTypeAdapterFactory.BoundField createBoundField(
+  private BoundField createBoundField(
       final Gson context, final Field field, final Method accessor, final String name,
       final TypeToken<?> fieldType, boolean serialize, boolean deserialize,
       final boolean blockInaccessible) {
@@ -161,7 +161,7 @@ public final class ReflectiveTypeAdapterFactory implements TypeAdapterFactory {
 
     @SuppressWarnings("unchecked")
     final TypeAdapter<Object> typeAdapter = (TypeAdapter<Object>) mapped;
-    return new ReflectiveTypeAdapterFactory.BoundField(name, field.getName(), serialize, deserialize) {
+    return new BoundField(name, field, serialize, deserialize) {
       @Override void write(JsonWriter writer, Object source)
           throws IOException, IllegalAccessException {
         if (!serialized) return;
@@ -232,7 +232,6 @@ public final class ReflectiveTypeAdapterFactory implements TypeAdapterFactory {
       return result;
     }
 
-    Type declaredType = type.getType();
     Class<?> originalRaw = raw;
     while (raw != Object.class) {
       Field[] fields = raw.getDeclaredFields();
@@ -298,8 +297,9 @@ public final class ReflectiveTypeAdapterFactory implements TypeAdapterFactory {
           if (previous == null) previous = replaced;
         }
         if (previous != null) {
-          throw new IllegalArgumentException(declaredType
-              + " declares multiple JSON fields named " + previous.name);
+          throw new IllegalArgumentException("Class " + originalRaw.getName()
+              + " declares multiple JSON fields named '" + previous.name + "'; conflict is caused"
+              + " by fields " + ReflectionHelper.fieldToString(previous.field) + " and " + ReflectionHelper.fieldToString(field));
         }
       }
       type = TypeToken.get($Gson$Types.resolve(type.getType(), raw, raw.getGenericSuperclass()));
@@ -310,14 +310,16 @@ public final class ReflectiveTypeAdapterFactory implements TypeAdapterFactory {
 
   static abstract class BoundField {
     final String name;
+    final Field field;
     /** Name of the underlying field */
     final String fieldName;
     final boolean serialized;
     final boolean deserialized;
 
-    protected BoundField(String name, String fieldName, boolean serialized, boolean deserialized) {
+    protected BoundField(String name, Field field, boolean serialized, boolean deserialized) {
       this.name = name;
-      this.fieldName = fieldName;
+      this.field = field;
+      this.fieldName = field.getName();
       this.serialized = serialized;
       this.deserialized = deserialized;
     }
diff --git a/gson/src/main/java/com/google/gson/internal/bind/TreeTypeAdapter.java b/gson/src/main/java/com/google/gson/internal/bind/TreeTypeAdapter.java
index 560234c0..2efd6c6b 100644
--- a/gson/src/main/java/com/google/gson/internal/bind/TreeTypeAdapter.java
+++ b/gson/src/main/java/com/google/gson/internal/bind/TreeTypeAdapter.java
@@ -176,7 +176,7 @@ public final class TreeTypeAdapter<T> extends SerializationDelegatingTypeAdapter
     }
     @SuppressWarnings("unchecked")
     @Override public <R> R deserialize(JsonElement json, Type typeOfT) throws JsonParseException {
-      return (R) gson.fromJson(json, typeOfT);
+      return gson.fromJson(json, typeOfT);
     }
   }
 }
diff --git a/gson/src/main/java/com/google/gson/internal/reflect/ReflectionHelper.java b/gson/src/main/java/com/google/gson/internal/reflect/ReflectionHelper.java
index ac061212..737bb5d4 100644
--- a/gson/src/main/java/com/google/gson/internal/reflect/ReflectionHelper.java
+++ b/gson/src/main/java/com/google/gson/internal/reflect/ReflectionHelper.java
@@ -53,8 +53,7 @@ public class ReflectionHelper {
     String description;
 
     if (object instanceof Field) {
-      Field field = (Field) object;
-      description = "field '" + field.getDeclaringClass().getName() + "#" + field.getName() + "'";
+      description = "field '" + fieldToString((Field) object) + "'";
     } else if (object instanceof Method) {
       Method method = (Method) object;
 
@@ -75,6 +74,14 @@ public class ReflectionHelper {
     return description;
   }
 
+  /**
+   * Creates a string representation for a field, omitting modifiers and
+   * the field type.
+   */
+  public static String fieldToString(Field field) {
+    return field.getDeclaringClass().getName() + "#" + field.getName();
+  }
+
   /**
    * Creates a string representation for a constructor.
    * E.g.: {@code java.lang.String(char[], int, int)}
diff --git a/gson/src/main/java/com/google/gson/stream/JsonReader.java b/gson/src/main/java/com/google/gson/stream/JsonReader.java
index 7557426f..23b7fc78 100644
--- a/gson/src/main/java/com/google/gson/stream/JsonReader.java
+++ b/gson/src/main/java/com/google/gson/stream/JsonReader.java
@@ -759,7 +759,9 @@ public class JsonReader implements Closeable {
     }
 
     // We've read a complete number. Decide if it's a PEEKED_LONG or a PEEKED_NUMBER.
-    if (last == NUMBER_CHAR_DIGIT && fitsInLong && (value != Long.MIN_VALUE || negative) && (value!=0 || false==negative)) {
+    // Don't store -0 as long; user might want to read it as double -0.0
+    // Don't try to convert Long.MIN_VALUE to positive long; it would overflow MAX_VALUE
+    if (last == NUMBER_CHAR_DIGIT && fitsInLong && (value != Long.MIN_VALUE || negative) && (value!=0 || !negative)) {
       peekedLong = negative ? value : -value;
       pos += i;
       return peeked = PEEKED_LONG;
@@ -1571,7 +1573,7 @@ public class JsonReader implements Closeable {
   }
 
   /**
-   * Returns a <a href="https://goessner.net/articles/JsonPath/">JsonPath</a>
+   * Returns a <a href="https://goessner.net/articles/JsonPath/">JSONPath</a>
    * in <i>dot-notation</i> to the previous (or current) location in the JSON document:
    * <ul>
    *   <li>For JSON arrays the path points to the index of the previous element.<br>
@@ -1588,7 +1590,7 @@ public class JsonReader implements Closeable {
   }
 
   /**
-   * Returns a <a href="https://goessner.net/articles/JsonPath/">JsonPath</a>
+   * Returns a <a href="https://goessner.net/articles/JsonPath/">JSONPath</a>
    * in <i>dot-notation</i> to the next (or current) location in the JSON document:
    * <ul>
    *   <li>For JSON arrays the path points to the index of the next element (even
diff --git a/gson/src/test/java/com/google/gson/DefaultInetAddressTypeAdapterTest.java b/gson/src/test/java/com/google/gson/DefaultInetAddressTypeAdapterTest.java
index 6b853f5d..3edee56a 100644
--- a/gson/src/test/java/com/google/gson/DefaultInetAddressTypeAdapterTest.java
+++ b/gson/src/test/java/com/google/gson/DefaultInetAddressTypeAdapterTest.java
@@ -16,30 +16,32 @@
 
 package com.google.gson;
 
-import java.net.InetAddress;
+import static com.google.common.truth.Truth.assertThat;
 
-import junit.framework.TestCase;
+import java.net.InetAddress;
+import org.junit.Before;
+import org.junit.Test;
 
 /**
  * Unit tests for the default serializer/deserializer for the {@code InetAddress} type.
  * 
  * @author Joel Leitch
  */
-public class DefaultInetAddressTypeAdapterTest extends TestCase {
+public class DefaultInetAddressTypeAdapterTest {
   private Gson gson;
   
-  @Override
-  protected void setUp() throws Exception {
-    super.setUp();
+  @Before
+  public void setUp() throws Exception {
     gson = new Gson();
   }
   
+  @Test
   public void testInetAddressSerializationAndDeserialization() throws Exception {
     InetAddress address = InetAddress.getByName("8.8.8.8");
     String jsonAddress = gson.toJson(address);
-    assertEquals("\"8.8.8.8\"", jsonAddress);
-    
+    assertThat(jsonAddress).isEqualTo("\"8.8.8.8\"");
+
     InetAddress value = gson.fromJson(jsonAddress, InetAddress.class);
-    assertEquals(value, address);
-  } 
+    assertThat(address).isEqualTo(value);
+  }
 }
diff --git a/gson/src/test/java/com/google/gson/DefaultMapJsonSerializerTest.java b/gson/src/test/java/com/google/gson/DefaultMapJsonSerializerTest.java
index 624b8637..75bc43e3 100644
--- a/gson/src/test/java/com/google/gson/DefaultMapJsonSerializerTest.java
+++ b/gson/src/test/java/com/google/gson/DefaultMapJsonSerializerTest.java
@@ -16,11 +16,13 @@
 
 package com.google.gson;
 
+import static com.google.common.truth.Truth.assertThat;
+
 import com.google.gson.reflect.TypeToken;
 import java.lang.reflect.Type;
 import java.util.HashMap;
 import java.util.Map;
-import junit.framework.TestCase;
+import org.junit.Test;
 
 /**
  * Unit test for the default JSON map serialization object located in the
@@ -28,27 +30,30 @@ import junit.framework.TestCase;
  *
  * @author Joel Leitch
  */
-public class DefaultMapJsonSerializerTest extends TestCase {
+public class DefaultMapJsonSerializerTest {
   private Gson gson = new Gson();
 
+  @Test
   public void testEmptyMapNoTypeSerialization() {
     Map<String, String> emptyMap = new HashMap<>();
     JsonElement element = gson.toJsonTree(emptyMap, emptyMap.getClass());
-    assertTrue(element instanceof JsonObject);
+    assertThat(element).isInstanceOf(JsonObject.class);
     JsonObject emptyMapJsonObject = (JsonObject) element;
-    assertTrue(emptyMapJsonObject.entrySet().isEmpty());
+    assertThat(emptyMapJsonObject.entrySet()).isEmpty();
   }
 
+  @Test
   public void testEmptyMapSerialization() {
     Type mapType = new TypeToken<Map<String, String>>() { }.getType();
     Map<String, String> emptyMap = new HashMap<>();
     JsonElement element = gson.toJsonTree(emptyMap, mapType);
 
-    assertTrue(element instanceof JsonObject);
+    assertThat(element).isInstanceOf(JsonObject.class);
     JsonObject emptyMapJsonObject = (JsonObject) element;
-    assertTrue(emptyMapJsonObject.entrySet().isEmpty());
+    assertThat(emptyMapJsonObject.entrySet()).isEmpty();
   }
 
+  @Test
   public void testNonEmptyMapSerialization() {
     Type mapType = new TypeToken<Map<String, String>>() { }.getType();
     Map<String, String> myMap = new HashMap<>();
@@ -57,8 +62,8 @@ public class DefaultMapJsonSerializerTest extends TestCase {
     Gson gson = new Gson();
     JsonElement element = gson.toJsonTree(myMap, mapType);
 
-    assertTrue(element.isJsonObject());
+    assertThat(element.isJsonObject()).isTrue();
     JsonObject mapJsonObject = element.getAsJsonObject();
-    assertTrue(mapJsonObject.has(key));
+    assertThat(mapJsonObject.has(key)).isTrue();
   }
 }
diff --git a/gson/src/test/java/com/google/gson/ExposeAnnotationExclusionStrategyTest.java b/gson/src/test/java/com/google/gson/ExposeAnnotationExclusionStrategyTest.java
index dd8a7a92..17aca036 100644
--- a/gson/src/test/java/com/google/gson/ExposeAnnotationExclusionStrategyTest.java
+++ b/gson/src/test/java/com/google/gson/ExposeAnnotationExclusionStrategyTest.java
@@ -16,54 +16,60 @@
 
 package com.google.gson;
 
+import static com.google.common.truth.Truth.assertThat;
+
 import com.google.gson.annotations.Expose;
-
 import com.google.gson.internal.Excluder;
-import junit.framework.TestCase;
-
 import java.lang.reflect.Field;
+import org.junit.Test;
 
 /**
  * Unit tests for GsonBuilder.REQUIRE_EXPOSE_DESERIALIZE.
  *
  * @author Joel Leitch
  */
-public class ExposeAnnotationExclusionStrategyTest extends TestCase {
+public class ExposeAnnotationExclusionStrategyTest {
   private Excluder excluder = Excluder.DEFAULT.excludeFieldsWithoutExposeAnnotation();
 
-  public void testNeverSkipClasses() throws Exception {
-    assertFalse(excluder.excludeClass(MockObject.class, true));
-    assertFalse(excluder.excludeClass(MockObject.class, false));
+  @Test
+  public void testNeverSkipClasses() {
+    assertThat(excluder.excludeClass(MockObject.class, true)).isFalse();
+    assertThat(excluder.excludeClass(MockObject.class, false)).isFalse();
   }
 
+  @Test
   public void testSkipNonAnnotatedFields() throws Exception {
     Field f = createFieldAttributes("hiddenField");
-    assertTrue(excluder.excludeField(f, true));
-    assertTrue(excluder.excludeField(f, false));
+    assertThat(excluder.excludeField(f, true)).isTrue();
+    assertThat(excluder.excludeField(f, false)).isTrue();
   }
 
+  @Test
   public void testSkipExplicitlySkippedFields() throws Exception {
     Field f = createFieldAttributes("explicitlyHiddenField");
-    assertTrue(excluder.excludeField(f, true));
-    assertTrue(excluder.excludeField(f, false));
+    assertThat(excluder.excludeField(f, true)).isTrue();
+    assertThat(excluder.excludeField(f, false)).isTrue();
   }
 
+  @Test
   public void testNeverSkipExposedAnnotatedFields() throws Exception {
     Field f = createFieldAttributes("exposedField");
-    assertFalse(excluder.excludeField(f, true));
-    assertFalse(excluder.excludeField(f, false));
+    assertThat(excluder.excludeField(f, true)).isFalse();
+    assertThat(excluder.excludeField(f, false)).isFalse();
   }
 
+  @Test
   public void testNeverSkipExplicitlyExposedAnnotatedFields() throws Exception {
     Field f = createFieldAttributes("explicitlyExposedField");
-    assertFalse(excluder.excludeField(f, true));
-    assertFalse(excluder.excludeField(f, false));
+    assertThat(excluder.excludeField(f, true)).isFalse();
+    assertThat(excluder.excludeField(f, false)).isFalse();
   }
 
+  @Test
   public void testDifferentSerializeAndDeserializeField() throws Exception {
     Field f = createFieldAttributes("explicitlyDifferentModeField");
-    assertFalse(excluder.excludeField(f, true));
-    assertTrue(excluder.excludeField(f, false));
+    assertThat(excluder.excludeField(f, true)).isFalse();
+    assertThat(excluder.excludeField(f, false)).isTrue();
   }
 
   private static Field createFieldAttributes(String fieldName) throws Exception {
diff --git a/gson/src/test/java/com/google/gson/FieldAttributesTest.java b/gson/src/test/java/com/google/gson/FieldAttributesTest.java
index 31be3e28..5e79c1f1 100644
--- a/gson/src/test/java/com/google/gson/FieldAttributesTest.java
+++ b/gson/src/test/java/com/google/gson/FieldAttributesTest.java
@@ -16,11 +16,15 @@
 
 package com.google.gson;
 
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.fail;
+
 import com.google.gson.reflect.TypeToken;
 import java.lang.reflect.Modifier;
 import java.lang.reflect.Type;
 import java.util.List;
-import junit.framework.TestCase;
+import org.junit.Before;
+import org.junit.Test;
 
 /**
  * Unit tests for the {@link FieldAttributes} class.
@@ -28,46 +32,50 @@ import junit.framework.TestCase;
  * @author Inderjeet Singh
  * @author Joel Leitch
  */
-public class FieldAttributesTest extends TestCase {
+public class FieldAttributesTest {
   private FieldAttributes fieldAttributes;
 
-  @Override
-  protected void setUp() throws Exception {
-    super.setUp();
+  @Before
+  public void setUp() throws Exception {
     fieldAttributes = new FieldAttributes(Foo.class.getField("bar"));
   }
 
   @SuppressWarnings("unused")
-  public void testNullField() throws Exception {
+  @Test
+  public void testNullField() {
     try {
       new FieldAttributes(null);
       fail("Field parameter can not be null");
     } catch (NullPointerException expected) { }
   }
 
-  public void testDeclaringClass() throws Exception {
-    assertEquals(Foo.class, fieldAttributes.getDeclaringClass());
+  @Test
+  public void testDeclaringClass() {
+    assertThat(fieldAttributes.getDeclaringClass()).isAssignableTo(Foo.class);
   }
 
-  public void testModifiers() throws Exception {
-    assertFalse(fieldAttributes.hasModifier(Modifier.STATIC));
-    assertFalse(fieldAttributes.hasModifier(Modifier.FINAL));
-    assertFalse(fieldAttributes.hasModifier(Modifier.ABSTRACT));
-    assertFalse(fieldAttributes.hasModifier(Modifier.VOLATILE));
-    assertFalse(fieldAttributes.hasModifier(Modifier.PROTECTED));
+  @Test
+  public void testModifiers() {
+    assertThat(fieldAttributes.hasModifier(Modifier.STATIC)).isFalse();
+    assertThat(fieldAttributes.hasModifier(Modifier.FINAL)).isFalse();
+    assertThat(fieldAttributes.hasModifier(Modifier.ABSTRACT)).isFalse();
+    assertThat(fieldAttributes.hasModifier(Modifier.VOLATILE)).isFalse();
+    assertThat(fieldAttributes.hasModifier(Modifier.PROTECTED)).isFalse();
 
-    assertTrue(fieldAttributes.hasModifier(Modifier.PUBLIC));
-    assertTrue(fieldAttributes.hasModifier(Modifier.TRANSIENT));
+    assertThat(fieldAttributes.hasModifier(Modifier.PUBLIC)).isTrue();
+    assertThat(fieldAttributes.hasModifier(Modifier.TRANSIENT)).isTrue();
   }
 
-  public void testName() throws Exception {
-    assertEquals("bar", fieldAttributes.getName());
+  @Test
+  public void testName() {
+    assertThat(fieldAttributes.getName()).isEqualTo("bar");
   }
 
-  public void testDeclaredTypeAndClass() throws Exception {
+  @Test
+  public void testDeclaredTypeAndClass() {
     Type expectedType = new TypeToken<List<String>>() {}.getType();
-    assertEquals(expectedType, fieldAttributes.getDeclaredType());
-    assertEquals(List.class, fieldAttributes.getDeclaredClass());
+    assertThat(fieldAttributes.getDeclaredType()).isEqualTo(expectedType);
+    assertThat(fieldAttributes.getDeclaredClass()).isAssignableTo(List.class);
   }
 
   private static class Foo {
diff --git a/gson/src/test/java/com/google/gson/FieldNamingPolicyTest.java b/gson/src/test/java/com/google/gson/FieldNamingPolicyTest.java
index 4d4c716b..ebb7f0aa 100644
--- a/gson/src/test/java/com/google/gson/FieldNamingPolicyTest.java
+++ b/gson/src/test/java/com/google/gson/FieldNamingPolicyTest.java
@@ -1,7 +1,8 @@
 package com.google.gson;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotEquals;
+import static com.google.common.truth.Truth.assertThat;
+import static com.google.common.truth.Truth.assertWithMessage;
+
 import java.lang.reflect.Field;
 import java.util.Locale;
 import org.junit.Test;
@@ -28,7 +29,7 @@ public class FieldNamingPolicyTest {
     };
 
     for (String[] pair : argumentPairs) {
-      assertEquals(pair[1], FieldNamingPolicy.separateCamelCase(pair[0], '_'));
+      assertThat(FieldNamingPolicy.separateCamelCase(pair[0], '_')).isEqualTo(pair[1]);
     }
   }
 
@@ -51,12 +52,12 @@ public class FieldNamingPolicyTest {
     };
 
     for (String[] pair : argumentPairs) {
-      assertEquals(pair[1], FieldNamingPolicy.upperCaseFirstLetter(pair[0]));
+      assertThat(FieldNamingPolicy.upperCaseFirstLetter(pair[0])).isEqualTo(pair[1]);
     }
   }
 
   /**
-   * Upper casing policies should be unaffected by default Locale.
+   * Upper-casing policies should be unaffected by default Locale.
    */
   @Test
   public void testUpperCasingLocaleIndependent() throws Exception {
@@ -81,11 +82,13 @@ public class FieldNamingPolicyTest {
 
     try {
       // Verify that default Locale has different case conversion rules
-      assertNotEquals("Test setup is broken", expected, name.toUpperCase());
+      assertWithMessage("Test setup is broken")
+          .that(name.toUpperCase()).doesNotMatch(expected);
 
       for (FieldNamingPolicy policy : policies) {
         // Should ignore default Locale
-        assertEquals("Unexpected conversion for " + policy, expected, policy.translateName(field));
+        assertWithMessage("Unexpected conversion for %s", policy)
+            .that(policy.translateName(field)).matches(expected);
       }
     } finally {
         Locale.setDefault(oldLocale);
@@ -118,11 +121,13 @@ public class FieldNamingPolicyTest {
 
     try {
       // Verify that default Locale has different case conversion rules
-      assertNotEquals("Test setup is broken", expected, name.toLowerCase());
+      assertWithMessage("Test setup is broken")
+          .that(name.toLowerCase()).doesNotMatch(expected);
 
       for (FieldNamingPolicy policy : policies) {
         // Should ignore default Locale
-        assertEquals("Unexpected conversion for " + policy, expected, policy.translateName(field));
+        assertWithMessage("Unexpected conversion for %s", policy)
+            .that(policy.translateName(field)).matches(expected);
       }
     } finally {
         Locale.setDefault(oldLocale);
diff --git a/gson/src/test/java/com/google/gson/GenericArrayTypeTest.java b/gson/src/test/java/com/google/gson/GenericArrayTypeTest.java
index 42acb8a2..4b300d25 100644
--- a/gson/src/test/java/com/google/gson/GenericArrayTypeTest.java
+++ b/gson/src/test/java/com/google/gson/GenericArrayTypeTest.java
@@ -16,14 +16,15 @@
 
 package com.google.gson;
 
+import static com.google.common.truth.Truth.assertThat;
+
 import com.google.gson.internal.$Gson$Types;
 import com.google.gson.reflect.TypeToken;
-
-import junit.framework.TestCase;
-
 import java.lang.reflect.GenericArrayType;
 import java.lang.reflect.Type;
 import java.util.List;
+import org.junit.Before;
+import org.junit.Test;
 
 /**
  * Unit tests for the {@code GenericArrayType}s created by the {@link $Gson$Types} class.
@@ -31,27 +32,28 @@ import java.util.List;
  * @author Inderjeet Singh
  * @author Joel Leitch
  */
-public class GenericArrayTypeTest extends TestCase {
+public class GenericArrayTypeTest {
   private GenericArrayType ourType;
 
-  @Override
-  protected void setUp() throws Exception {
-    super.setUp();
+  @Before
+  public void setUp() throws Exception {
     ourType = $Gson$Types.arrayOf($Gson$Types.newParameterizedTypeWithOwner(null, List.class, String.class));
   }
 
+  @Test
   public void testOurTypeFunctionality() throws Exception {
     Type parameterizedType = new TypeToken<List<String>>() {}.getType();
     Type genericArrayType = new TypeToken<List<String>[]>() {}.getType();
 
-    assertEquals(parameterizedType, ourType.getGenericComponentType());
-    assertEquals(genericArrayType, ourType);
-    assertEquals(genericArrayType.hashCode(), ourType.hashCode());
+    assertThat(ourType.getGenericComponentType()).isEqualTo(parameterizedType);
+    assertThat(ourType).isEqualTo(genericArrayType);
+    assertThat(ourType.hashCode()).isEqualTo(genericArrayType.hashCode());
   }
 
+  @Test
   public void testNotEquals() throws Exception {
     Type differentGenericArrayType = new TypeToken<List<String>[][]>() {}.getType();
-    assertFalse(differentGenericArrayType.equals(ourType));
-    assertFalse(ourType.equals(differentGenericArrayType));
+    assertThat(differentGenericArrayType.equals(ourType)).isFalse();
+    assertThat(ourType.equals(differentGenericArrayType)).isFalse();
   }
 }
diff --git a/gson/src/test/java/com/google/gson/GsonBuilderTest.java b/gson/src/test/java/com/google/gson/GsonBuilderTest.java
index e1a013b5..4c6d5ec9 100644
--- a/gson/src/test/java/com/google/gson/GsonBuilderTest.java
+++ b/gson/src/test/java/com/google/gson/GsonBuilderTest.java
@@ -16,9 +16,7 @@
 
 package com.google.gson;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNotSame;
+import static com.google.common.truth.Truth.assertThat;
 import static org.junit.Assert.fail;
 
 import com.google.gson.stream.JsonReader;
@@ -48,8 +46,8 @@ public class GsonBuilderTest {
   public void testCreatingMoreThanOnce() {
     GsonBuilder builder = new GsonBuilder();
     Gson gson = builder.create();
-    assertNotNull(gson);
-    assertNotNull(builder.create());
+    assertThat(gson).isNotNull();
+    assertThat(builder.create()).isNotNull();
 
     builder.setFieldNamingStrategy(new FieldNamingStrategy() {
       @Override public String translateName(Field f) {
@@ -58,9 +56,9 @@ public class GsonBuilderTest {
     });
 
     Gson otherGson = builder.create();
-    assertNotNull(otherGson);
+    assertThat(otherGson).isNotNull();
     // Should be different instances because builder has been modified in the meantime
-    assertNotSame(gson, otherGson);
+    assertThat(gson).isNotSameInstanceAs(otherGson);
   }
 
   /**
@@ -74,7 +72,7 @@ public class GsonBuilderTest {
 
     // Modifications of `gsonBuilder` should not affect `gson` object
     gsonBuilder.registerTypeAdapter(CustomClass1.class, new TypeAdapter<CustomClass1>() {
-      @Override public CustomClass1 read(JsonReader in) throws IOException {
+      @Override public CustomClass1 read(JsonReader in) {
         throw new UnsupportedOperationException();
       }
 
@@ -93,6 +91,7 @@ public class GsonBuilderTest {
       }
     });
 
+
     assertDefaultGson(gson);
     // New GsonBuilder created from `gson` should not have been affected by changes
     // to `gsonBuilder` either
@@ -105,26 +104,26 @@ public class GsonBuilderTest {
   private static void assertDefaultGson(Gson gson) {
     // Should use default reflective adapter
     String json1 = gson.toJson(new CustomClass1());
-    assertEquals("{}", json1);
+    assertThat(json1).isEqualTo("{}");
 
     // Should use default reflective adapter
     String json2 = gson.toJson(new CustomClass2());
-    assertEquals("{}", json2);
+    assertThat(json2).isEqualTo("{}");
 
     // Should use default instance creator
     CustomClass3 customClass3 = gson.fromJson("{}", CustomClass3.class);
-    assertEquals(CustomClass3.NO_ARG_CONSTRUCTOR_VALUE, customClass3.s);
+    assertThat(customClass3.s).isEqualTo(CustomClass3.NO_ARG_CONSTRUCTOR_VALUE);
   }
 
   private static void assertCustomGson(Gson gson) {
     String json1 = gson.toJson(new CustomClass1());
-    assertEquals("\"custom-adapter\"", json1);
+    assertThat(json1).isEqualTo("\"custom-adapter\"");
 
     String json2 = gson.toJson(new CustomClass2());
-    assertEquals("\"custom-hierarchy-adapter\"", json2);
+    assertThat(json2).isEqualTo("\"custom-hierarchy-adapter\"");
 
     CustomClass3 customClass3 = gson.fromJson("{}", CustomClass3.class);
-    assertEquals("custom-instance", customClass3.s);
+    assertThat(customClass3.s).isEqualTo("custom-instance");
   }
 
   static class CustomClass1 { }
@@ -148,7 +147,7 @@ public class GsonBuilderTest {
     Gson gson = new GsonBuilder()
         .excludeFieldsWithModifiers(Modifier.VOLATILE, Modifier.PRIVATE)
         .create();
-    assertEquals("{\"d\":\"d\"}", gson.toJson(new HasModifiers()));
+    assertThat(gson.toJson(new HasModifiers())).isEqualTo("{\"d\":\"d\"}");
   }
 
   @SuppressWarnings("unused")
@@ -164,7 +163,7 @@ public class GsonBuilderTest {
     Gson gson = new GsonBuilder()
         .excludeFieldsWithModifiers()
         .create();
-    assertEquals("{\"a\":\"a\"}", gson.toJson(new HasTransients()));
+    assertThat(gson.toJson(new HasTransients())).isEqualTo("{\"a\":\"a\"}");
   }
 
   static class HasTransients {
@@ -195,12 +194,10 @@ public class GsonBuilderTest {
       gson.fromJson("{}", ClassWithoutNoArgsConstructor.class);
       fail("Expected exception");
     } catch (JsonIOException expected) {
-      assertEquals(
-        "Unable to create instance of class com.google.gson.GsonBuilderTest$ClassWithoutNoArgsConstructor; "
-        + "usage of JDK Unsafe is disabled. Registering an InstanceCreator or a TypeAdapter for this type, "
-        + "adding a no-args constructor, or enabling usage of JDK Unsafe may fix this problem.",
-        expected.getMessage()
-      );
+      assertThat(expected).hasMessageThat().isEqualTo(
+          "Unable to create instance of class com.google.gson.GsonBuilderTest$ClassWithoutNoArgsConstructor; "
+          + "usage of JDK Unsafe is disabled. Registering an InstanceCreator or a TypeAdapter for this type, "
+          + "adding a no-args constructor, or enabling usage of JDK Unsafe may fix this problem.");
     }
   }
 
@@ -217,14 +214,14 @@ public class GsonBuilderTest {
       builder.setVersion(Double.NaN);
       fail();
     } catch (IllegalArgumentException e) {
-      assertEquals("Invalid version: NaN", e.getMessage());
+      assertThat(e).hasMessageThat().isEqualTo("Invalid version: NaN");
     }
 
     try {
       builder.setVersion(-0.1);
       fail();
     } catch (IllegalArgumentException e) {
-      assertEquals("Invalid version: -0.1", e.getMessage());
+      assertThat(e).hasMessageThat().isEqualTo("Invalid version: -0.1");
     }
   }
 }
diff --git a/gson/src/test/java/com/google/gson/GsonTest.java b/gson/src/test/java/com/google/gson/GsonTest.java
index e5a08930..4b3b1e9d 100644
--- a/gson/src/test/java/com/google/gson/GsonTest.java
+++ b/gson/src/test/java/com/google/gson/GsonTest.java
@@ -16,6 +16,10 @@
 
 package com.google.gson;
 
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.fail;
+
+import com.google.gson.Gson.FutureTypeAdapter;
 import com.google.gson.internal.Excluder;
 import com.google.gson.reflect.TypeToken;
 import com.google.gson.stream.JsonReader;
@@ -30,16 +34,17 @@ import java.text.DateFormat;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
+import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicReference;
-import junit.framework.TestCase;
+import org.junit.Test;
 
 /**
  * Unit tests for {@link Gson}.
  *
  * @author Ryan Harter
  */
-public final class GsonTest extends TestCase {
+public final class GsonTest {
 
   private static final Excluder CUSTOM_EXCLUDER = Excluder.DEFAULT
       .excludeFieldsWithoutExposeAnnotation()
@@ -54,6 +59,7 @@ public final class GsonTest extends TestCase {
   private static final ToNumberStrategy CUSTOM_OBJECT_TO_NUMBER_STRATEGY = ToNumberPolicy.DOUBLE;
   private static final ToNumberStrategy CUSTOM_NUMBER_TO_NUMBER_STRATEGY = ToNumberPolicy.LAZILY_PARSED_NUMBER;
 
+  @Test
   public void testOverridesDefaultExcluder() {
     Gson gson = new Gson(CUSTOM_EXCLUDER, CUSTOM_FIELD_NAMING_STRATEGY,
         new HashMap<Type, InstanceCreator<?>>(), true, false, false, true, false,
@@ -63,12 +69,13 @@ public final class GsonTest extends TestCase {
         CUSTOM_OBJECT_TO_NUMBER_STRATEGY, CUSTOM_NUMBER_TO_NUMBER_STRATEGY,
         Collections.<ReflectionAccessFilter>emptyList());
 
-    assertEquals(CUSTOM_EXCLUDER, gson.excluder);
-    assertEquals(CUSTOM_FIELD_NAMING_STRATEGY, gson.fieldNamingStrategy());
-    assertEquals(true, gson.serializeNulls());
-    assertEquals(false, gson.htmlSafe());
+    assertThat(gson.excluder).isEqualTo(CUSTOM_EXCLUDER);
+    assertThat(gson.fieldNamingStrategy()).isEqualTo(CUSTOM_FIELD_NAMING_STRATEGY);
+    assertThat(gson.serializeNulls()).isTrue();
+    assertThat(gson.htmlSafe()).isFalse();
   }
 
+  @Test
   public void testClonedTypeAdapterFactoryListsAreIndependent() {
     Gson original = new Gson(CUSTOM_EXCLUDER, CUSTOM_FIELD_NAMING_STRATEGY,
         new HashMap<Type, InstanceCreator<?>>(), true, false, false, true, false,
@@ -82,34 +89,36 @@ public final class GsonTest extends TestCase {
         .registerTypeAdapter(Object.class, new TestTypeAdapter())
         .create();
 
-    assertEquals(original.factories.size() + 1, clone.factories.size());
+    assertThat(clone.factories).hasSize(original.factories.size() + 1);
   }
 
   private static final class TestTypeAdapter extends TypeAdapter<Object> {
-    @Override public void write(JsonWriter out, Object value) throws IOException {
+    @Override public void write(JsonWriter out, Object value) {
       // Test stub.
     }
-    @Override public Object read(JsonReader in) throws IOException { return null; }
+    @Override public Object read(JsonReader in) { return null; }
   }
 
+  @Test
   public void testGetAdapter_Null() {
     Gson gson = new Gson();
     try {
       gson.getAdapter((TypeToken<?>) null);
       fail();
     } catch (NullPointerException e) {
-      assertEquals("type must not be null", e.getMessage());
+      assertThat(e).hasMessageThat().isEqualTo("type must not be null");
     }
   }
 
+  @Test
   public void testGetAdapter_Concurrency() {
     class DummyAdapter<T> extends TypeAdapter<T> {
       @Override public void write(JsonWriter out, T value) throws IOException {
-        throw new AssertionError("not needed for test");
+        throw new AssertionError("not needed for this test");
       }
 
       @Override public T read(JsonReader in) throws IOException {
-        throw new AssertionError("not needed for test");
+        throw new AssertionError("not needed for this test");
       }
     }
 
@@ -149,12 +158,118 @@ public final class GsonTest extends TestCase {
         .create();
 
     TypeAdapter<?> adapter = gson.getAdapter(requestedType);
-    assertTrue(adapter instanceof DummyAdapter);
-    assertEquals(2, adapterInstancesCreated.get());
-    // Should be the same adapter instance the concurrent thread received
-    assertSame(threadAdapter.get(), adapter);
+    assertThat(adapterInstancesCreated.get()).isEqualTo(2);
+    assertThat(adapter).isInstanceOf(DummyAdapter.class);
+    assertThat(threadAdapter.get()).isInstanceOf(DummyAdapter.class);
   }
 
+  /**
+   * Verifies that two threads calling {@link Gson#getAdapter(TypeToken)} do not see the
+   * same unresolved {@link FutureTypeAdapter} instance, since that would not be thread-safe.
+   *
+   * This test constructs the cyclic dependency {@literal CustomClass1 -> CustomClass2 -> CustomClass1}
+   * and lets one thread wait after the adapter for CustomClass2 has been obtained (which still
+   * refers to the nested unresolved FutureTypeAdapter for CustomClass1).
+   */
+  @Test
+  public void testGetAdapter_FutureAdapterConcurrency() throws Exception {
+    /**
+     * Adapter which wraps another adapter. Can be imagined as a simplified version of the
+     * {@code ReflectiveTypeAdapterFactory$Adapter}.
+     */
+    class WrappingAdapter<T> extends TypeAdapter<T> {
+      final TypeAdapter<?> wrapped;
+      boolean isFirstCall = true;
+
+      WrappingAdapter(TypeAdapter<?> wrapped) {
+        this.wrapped = wrapped;
+      }
+
+      @Override public void write(JsonWriter out, T value) throws IOException {
+        // Due to how this test is set up there is infinite recursion, therefore
+        // need to track how deeply nested this call is
+        if (isFirstCall) {
+          isFirstCall = false;
+          out.beginArray();
+          wrapped.write(out, null);
+          out.endArray();
+          isFirstCall = true;
+        } else {
+          out.value("wrapped-nested");
+        }
+      }
+
+      @Override public T read(JsonReader in) throws IOException {
+        throw new AssertionError("not needed for this test");
+      }
+    }
+
+    final CountDownLatch isThreadWaiting = new CountDownLatch(1);
+    final CountDownLatch canThreadProceed = new CountDownLatch(1);
+
+    final Gson gson = new GsonBuilder()
+      .registerTypeAdapterFactory(new TypeAdapterFactory() {
+        // volatile instead of AtomicBoolean is safe here because CountDownLatch prevents
+        // "true" concurrency
+        volatile boolean isFirstCaller = true;
+
+        @Override
+        public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> type) {
+          Class<?> raw = type.getRawType();
+
+          if (raw == CustomClass1.class) {
+            // Retrieves a WrappingAdapter containing a nested FutureAdapter for CustomClass1
+            TypeAdapter<?> adapter = gson.getAdapter(CustomClass2.class);
+
+            // Let thread wait so the FutureAdapter for CustomClass1 nested in the adapter
+            // for CustomClass2 is not resolved yet
+            if (isFirstCaller) {
+              isFirstCaller = false;
+              isThreadWaiting.countDown();
+
+              try {
+                canThreadProceed.await();
+              } catch (InterruptedException e) {
+                throw new RuntimeException(e);
+              }
+            }
+
+            return new WrappingAdapter<>(adapter);
+          }
+          else if (raw == CustomClass2.class) {
+            TypeAdapter<?> adapter = gson.getAdapter(CustomClass1.class);
+            assertThat(adapter).isInstanceOf(FutureTypeAdapter.class);
+            return new WrappingAdapter<>(adapter);
+          }
+          else {
+            throw new AssertionError("Adapter for unexpected type requested: " + raw);
+          }
+        }
+      })
+      .create();
+
+    final AtomicReference<TypeAdapter<?>> otherThreadAdapter = new AtomicReference<>();
+    Thread thread = new Thread() {
+      @Override
+      public void run() {
+        otherThreadAdapter.set(gson.getAdapter(CustomClass1.class));
+      }
+    };
+    thread.start();
+
+    // Wait until other thread has obtained FutureAdapter
+    isThreadWaiting.await();
+    TypeAdapter<?> adapter = gson.getAdapter(CustomClass1.class);
+    // Should not fail due to referring to unresolved FutureTypeAdapter
+    assertThat(adapter.toJson(null)).isEqualTo("[[\"wrapped-nested\"]]");
+
+    // Let other thread proceed and have it resolve its FutureTypeAdapter
+    canThreadProceed.countDown();
+    thread.join();
+    assertThat(otherThreadAdapter.get().toJson(null)).isEqualTo("[[\"wrapped-nested\"]]");
+  }
+
+  @Test
   public void testNewJsonWriter_Default() throws IOException {
     StringWriter writer = new StringWriter();
     JsonWriter jsonWriter = new GsonBuilder().create().newJsonWriter(writer);
@@ -170,13 +285,14 @@ public final class GsonTest extends TestCase {
       jsonWriter.value(1);
       fail();
     } catch (IllegalStateException expected) {
-      assertEquals("JSON must have only one top-level value.", expected.getMessage());
+      assertThat(expected).hasMessageThat().isEqualTo("JSON must have only one top-level value.");
     }
 
     jsonWriter.close();
-    assertEquals("{\"\\u003ctest2\":true}", writer.toString());
+    assertThat(writer.toString()).isEqualTo("{\"\\u003ctest2\":true}");
   }
 
+  @Test
   public void testNewJsonWriter_Custom() throws IOException {
     StringWriter writer = new StringWriter();
     JsonWriter jsonWriter = new GsonBuilder()
@@ -198,9 +314,10 @@ public final class GsonTest extends TestCase {
     jsonWriter.value(1);
 
     jsonWriter.close();
-    assertEquals(")]}'\n{\n  \"test\": null,\n  \"<test2\": true\n}1", writer.toString());
+    assertThat(writer.toString()).isEqualTo(")]}'\n{\n  \"test\": null,\n  \"<test2\": true\n}1");
   }
 
+  @Test
   public void testNewJsonReader_Default() throws IOException {
     String json = "test"; // String without quotes
     JsonReader jsonReader = new GsonBuilder().create().newJsonReader(new StringReader(json));
@@ -212,13 +329,14 @@ public final class GsonTest extends TestCase {
     jsonReader.close();
   }
 
+  @Test
   public void testNewJsonReader_Custom() throws IOException {
     String json = "test"; // String without quotes
     JsonReader jsonReader = new GsonBuilder()
       .setLenient()
       .create()
       .newJsonReader(new StringReader(json));
-    assertEquals("test", jsonReader.nextString());
+    assertThat(jsonReader.nextString()).isEqualTo("test");
     jsonReader.close();
   }
 
@@ -226,6 +344,7 @@ public final class GsonTest extends TestCase {
    * Modifying a GsonBuilder obtained from {@link Gson#newBuilder()} of a
    * {@code new Gson()} should not affect the Gson instance it came from.
    */
+  @Test
   public void testDefaultGsonNewBuilderModification() {
     Gson gson = new Gson();
     GsonBuilder gsonBuilder = gson.newBuilder();
@@ -262,15 +381,15 @@ public final class GsonTest extends TestCase {
   private static void assertDefaultGson(Gson gson) {
     // Should use default reflective adapter
     String json1 = gson.toJson(new CustomClass1());
-    assertEquals("{}", json1);
+    assertThat(json1).isEqualTo("{}");
 
     // Should use default reflective adapter
     String json2 = gson.toJson(new CustomClass2());
-    assertEquals("{}", json2);
+    assertThat(json2).isEqualTo("{}");
 
     // Should use default instance creator
     CustomClass3 customClass3 = gson.fromJson("{}", CustomClass3.class);
-    assertEquals(CustomClass3.NO_ARG_CONSTRUCTOR_VALUE, customClass3.s);
+    assertThat(customClass3.s).isEqualTo(CustomClass3.NO_ARG_CONSTRUCTOR_VALUE);
   }
 
   /**
@@ -278,6 +397,7 @@ public final class GsonTest extends TestCase {
    * Gson instance (created using a GsonBuilder) should not affect the Gson instance
    * it came from.
    */
+  @Test
   public void testNewBuilderModification() {
     Gson gson = new GsonBuilder()
       .registerTypeAdapter(CustomClass1.class, new TypeAdapter<CustomClass1>() {
@@ -333,29 +453,29 @@ public final class GsonTest extends TestCase {
     // But new Gson instance from `gsonBuilder` should be affected by changes
     Gson otherGson = gsonBuilder.create();
     String json1 = otherGson.toJson(new CustomClass1());
-    assertEquals("\"overwritten custom-adapter\"", json1);
+    assertThat(json1).isEqualTo("\"overwritten custom-adapter\"");
 
     String json2 = otherGson.toJson(new CustomClass2());
-    assertEquals("\"overwritten custom-hierarchy-adapter\"", json2);
+    assertThat(json2).isEqualTo("\"overwritten custom-hierarchy-adapter\"");
 
     CustomClass3 customClass3 = otherGson.fromJson("{}", CustomClass3.class);
-    assertEquals("overwritten custom-instance", customClass3.s);
+    assertThat(customClass3.s).isEqualTo("overwritten custom-instance");
   }
 
   private static void assertCustomGson(Gson gson) {
     String json1 = gson.toJson(new CustomClass1());
-    assertEquals("\"custom-adapter\"", json1);
+    assertThat(json1).isEqualTo("\"custom-adapter\"");
 
     String json2 = gson.toJson(new CustomClass2());
-    assertEquals("\"custom-hierarchy-adapter\"", json2);
+    assertThat(json2).isEqualTo("\"custom-hierarchy-adapter\"");
 
     CustomClass3 customClass3 = gson.fromJson("{}", CustomClass3.class);
-    assertEquals("custom-instance", customClass3.s);
+    assertThat(customClass3.s).isEqualTo("custom-instance");
   }
 
-  static class CustomClass1 { }
-  static class CustomClass2 { }
-  static class CustomClass3 {
+  private static class CustomClass1 { }
+  private static class CustomClass2 { }
+  private static class CustomClass3 {
     static final String NO_ARG_CONSTRUCTOR_VALUE = "default instance";
 
     final String s;
@@ -364,6 +484,7 @@ public final class GsonTest extends TestCase {
       this.s = s;
     }
 
+    @SuppressWarnings("unused") // called by Gson
     public CustomClass3() {
       this(NO_ARG_CONSTRUCTOR_VALUE);
     }
diff --git a/gson/src/test/java/com/google/gson/GsonTypeAdapterTest.java b/gson/src/test/java/com/google/gson/GsonTypeAdapterTest.java
index d92994fa..49aec3e8 100644
--- a/gson/src/test/java/com/google/gson/GsonTypeAdapterTest.java
+++ b/gson/src/test/java/com/google/gson/GsonTypeAdapterTest.java
@@ -16,11 +16,15 @@
 
 package com.google.gson;
 
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.fail;
+
 import java.lang.reflect.Type;
 import java.math.BigInteger;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicLong;
-import junit.framework.TestCase;
+import org.junit.Before;
+import org.junit.Test;
 
 /**
  * Contains numerous tests involving registered type converters with a Gson instance.
@@ -28,18 +32,18 @@ import junit.framework.TestCase;
  * @author Inderjeet Singh
  * @author Joel Leitch
  */
-public class GsonTypeAdapterTest extends TestCase {
+public class GsonTypeAdapterTest {
   private Gson gson;
 
-  @Override
-  protected void setUp() throws Exception {
-    super.setUp();
+  @Before
+  public void setUp() throws Exception {
     gson = new GsonBuilder()
         .registerTypeAdapter(AtomicLong.class, new ExceptionTypeAdapter())
         .registerTypeAdapter(AtomicInteger.class, new AtomicIntegerTypeAdapter())
         .create();
   }
 
+  @Test
   public void testDefaultTypeAdapterThrowsParseException() throws Exception {
     try {
       gson.fromJson("{\"abc\":123}", BigInteger.class);
@@ -47,6 +51,7 @@ public class GsonTypeAdapterTest extends TestCase {
     } catch (JsonParseException expected) { }
   }
 
+  @Test
   public void testTypeAdapterThrowsException() throws Exception {
     try {
       gson.toJson(new AtomicLong(0));
@@ -54,7 +59,7 @@ public class GsonTypeAdapterTest extends TestCase {
     } catch (IllegalStateException expected) { }
 
     // Verify that serializer is made null-safe, i.e. it is not called for null
-    assertEquals("null", gson.toJson(null, AtomicLong.class));
+    assertThat(gson.toJson(null, AtomicLong.class)).isEqualTo("null");
 
     try {
       gson.fromJson("123", AtomicLong.class);
@@ -62,26 +67,28 @@ public class GsonTypeAdapterTest extends TestCase {
     } catch (JsonParseException expected) { }
 
     // Verify that deserializer is made null-safe, i.e. it is not called for null
-    assertNull(gson.fromJson(JsonNull.INSTANCE, AtomicLong.class));
+    assertThat(gson.fromJson(JsonNull.INSTANCE, AtomicLong.class)).isNull();
   }
 
-  public void testTypeAdapterProperlyConvertsTypes() throws Exception {
+  @Test
+  public void testTypeAdapterProperlyConvertsTypes() {
     int intialValue = 1;
     AtomicInteger atomicInt = new AtomicInteger(intialValue);
     String json = gson.toJson(atomicInt);
-    assertEquals(intialValue + 1, Integer.parseInt(json));
+    assertThat(Integer.parseInt(json)).isEqualTo(intialValue + 1);
 
     atomicInt = gson.fromJson(json, AtomicInteger.class);
-    assertEquals(intialValue, atomicInt.get());
+    assertThat(atomicInt.get()).isEqualTo(intialValue);
   }
 
-  public void testTypeAdapterDoesNotAffectNonAdaptedTypes() throws Exception {
+  @Test
+  public void testTypeAdapterDoesNotAffectNonAdaptedTypes() {
     String expected = "blah";
     String actual = gson.toJson(expected);
-    assertEquals("\"" + expected + "\"", actual);
+    assertThat(actual).isEqualTo("\"" + expected + "\"");
 
     actual = gson.fromJson(actual, String.class);
-    assertEquals(expected, actual);
+    assertThat(actual).isEqualTo(expected);
   }
 
   private static class ExceptionTypeAdapter
@@ -119,6 +126,7 @@ public class GsonTypeAdapterTest extends TestCase {
   }
 
   // https://groups.google.com/d/topic/google-gson/EBmOCa8kJPE/discussion
+  @Test
   public void testDeserializerForAbstractClass() {
     Concrete instance = new Concrete();
     instance.a = "android";
@@ -149,6 +157,6 @@ public class GsonTypeAdapterTest extends TestCase {
       builder.registerTypeHierarchyAdapter(Abstract.class, deserializer);
     }
     Gson gson = builder.create();
-    assertEquals(expected, gson.toJson(instance, instanceType));
+    assertThat(gson.toJson(instance, instanceType)).isEqualTo(expected);
   }
 }
diff --git a/gson/src/test/java/com/google/gson/InnerClassExclusionStrategyTest.java b/gson/src/test/java/com/google/gson/InnerClassExclusionStrategyTest.java
index 86f7a622..67ad9b29 100644
--- a/gson/src/test/java/com/google/gson/InnerClassExclusionStrategyTest.java
+++ b/gson/src/test/java/com/google/gson/InnerClassExclusionStrategyTest.java
@@ -16,38 +16,44 @@
 
 package com.google.gson;
 
+import static com.google.common.truth.Truth.assertThat;
+
 import com.google.gson.internal.Excluder;
 import java.lang.reflect.Field;
-import junit.framework.TestCase;
+import org.junit.Test;
 
 /**
  * Unit test for GsonBuilder.EXCLUDE_INNER_CLASSES.
  *
  * @author Joel Leitch
  */
-public class InnerClassExclusionStrategyTest extends TestCase {
+public class InnerClassExclusionStrategyTest {
   public InnerClass innerClass = new InnerClass();
   public StaticNestedClass staticNestedClass = new StaticNestedClass();
   private Excluder excluder = Excluder.DEFAULT.disableInnerClassSerialization();
 
-  public void testExcludeInnerClassObject() throws Exception {
+  @Test
+  public void testExcludeInnerClassObject() {
     Class<?> clazz = innerClass.getClass();
-    assertTrue(excluder.excludeClass(clazz, true));
+    assertThat(excluder.excludeClass(clazz, true)).isTrue();
   }
 
+  @Test
   public void testExcludeInnerClassField() throws Exception {
     Field f = getClass().getField("innerClass");
-    assertTrue(excluder.excludeField(f, true));
+    assertThat(excluder.excludeField(f, true)).isTrue();
   }
 
-  public void testIncludeStaticNestedClassObject() throws Exception {
+  @Test
+  public void testIncludeStaticNestedClassObject() {
     Class<?> clazz = staticNestedClass.getClass();
-    assertFalse(excluder.excludeClass(clazz, true));
+    assertThat(excluder.excludeClass(clazz, true)).isFalse();
   }
 
+  @Test
   public void testIncludeStaticNestedClassField() throws Exception {
     Field f = getClass().getField("staticNestedClass");
-    assertFalse(excluder.excludeField(f, true));
+    assertThat(excluder.excludeField(f, true)).isFalse();
   }
 
   class InnerClass {
diff --git a/gson/src/test/java/com/google/gson/JavaSerializationTest.java b/gson/src/test/java/com/google/gson/JavaSerializationTest.java
index 90da3e85..d18a6f36 100644
--- a/gson/src/test/java/com/google/gson/JavaSerializationTest.java
+++ b/gson/src/test/java/com/google/gson/JavaSerializationTest.java
@@ -16,6 +16,8 @@
 
 package com.google.gson;
 
+import static com.google.common.truth.Truth.assertThat;
+
 import com.google.gson.reflect.TypeToken;
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
@@ -23,43 +25,44 @@ import java.io.IOException;
 import java.io.ObjectInputStream;
 import java.io.ObjectOutputStream;
 import java.lang.reflect.Type;
-import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
-import junit.framework.TestCase;
+import org.junit.Test;
 
 /**
  * Check that Gson doesn't return non-serializable data types.
  *
  * @author Jesse Wilson
  */
-public final class JavaSerializationTest extends TestCase {
+public final class JavaSerializationTest {
   private final Gson gson = new Gson();
 
+  @Test
   public void testMapIsSerializable() throws Exception {
     Type type = new TypeToken<Map<String, Integer>>() {}.getType();
     Map<String, Integer> map = gson.fromJson("{\"b\":1,\"c\":2,\"a\":3}", type);
     Map<String, Integer> serialized = serializedCopy(map);
-    assertEquals(map, serialized);
+    assertThat(serialized).isEqualTo(map);
     // Also check that the iteration order is retained.
-    assertEquals(Arrays.asList("b", "c", "a"), new ArrayList<>(serialized.keySet()));
+    assertThat(serialized.keySet()).containsExactly("b", "c", "a").inOrder();
   }
 
+  @Test
   public void testListIsSerializable() throws Exception {
     Type type = new TypeToken<List<String>>() {}.getType();
     List<String> list = gson.fromJson("[\"a\",\"b\",\"c\"]", type);
     List<String> serialized = serializedCopy(list);
-    assertEquals(list, serialized);
+    assertThat(serialized).isEqualTo(list);
   }
 
+  @Test
   public void testNumberIsSerializable() throws Exception {
     Type type = new TypeToken<List<Number>>() {}.getType();
     List<Number> list = gson.fromJson("[1,3.14,6.673e-11]", type);
     List<Number> serialized = serializedCopy(list);
-    assertEquals(1.0, serialized.get(0).doubleValue());
-    assertEquals(3.14, serialized.get(1).doubleValue());
-    assertEquals(6.673e-11, serialized.get(2).doubleValue());
+    assertThat(serialized.get(0).doubleValue()).isEqualTo(1.0);
+    assertThat(serialized.get(1).doubleValue()).isEqualTo(3.14);
+    assertThat(serialized.get(2).doubleValue()).isEqualTo(6.673e-11);
   }
 
   @SuppressWarnings("unchecked") // Serialization promises to return the same type.
diff --git a/gson/src/test/java/com/google/gson/JsonArrayAsListTest.java b/gson/src/test/java/com/google/gson/JsonArrayAsListTest.java
index a1786ce6..8c061204 100644
--- a/gson/src/test/java/com/google/gson/JsonArrayAsListTest.java
+++ b/gson/src/test/java/com/google/gson/JsonArrayAsListTest.java
@@ -1,10 +1,6 @@
 package com.google.gson;
 
-import static org.junit.Assert.assertArrayEquals;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertSame;
-import static org.junit.Assert.assertTrue;
+import static com.google.common.truth.Truth.assertThat;
 import static org.junit.Assert.fail;
 
 import com.google.gson.common.MoreAsserts;
@@ -23,7 +19,7 @@ public class JsonArrayAsListTest {
     a.add(1);
 
     List<JsonElement> list = a.asList();
-    assertEquals(new JsonPrimitive(1), list.get(0));
+    assertThat(list.get(0)).isEqualTo(new JsonPrimitive(1));
 
     try {
       list.get(-1);
@@ -38,7 +34,7 @@ public class JsonArrayAsListTest {
     }
 
     a.add((JsonElement) null);
-    assertEquals(JsonNull.INSTANCE, list.get(1));
+    assertThat(list.get(1)).isEqualTo(JsonNull.INSTANCE);
   }
 
   @Test
@@ -47,9 +43,9 @@ public class JsonArrayAsListTest {
     a.add(1);
 
     List<JsonElement> list = a.asList();
-    assertEquals(1, list.size());
+    assertThat(list).hasSize(1);
     list.add(new JsonPrimitive(2));
-    assertEquals(2, list.size());
+    assertThat(list).hasSize(2);
   }
 
   @Test
@@ -59,9 +55,9 @@ public class JsonArrayAsListTest {
 
     List<JsonElement> list = a.asList();
     JsonElement old = list.set(0, new JsonPrimitive(2));
-    assertEquals(new JsonPrimitive(1), old);
-    assertEquals(new JsonPrimitive(2), list.get(0));
-    assertEquals(new JsonPrimitive(2), a.get(0));
+    assertThat(old).isEqualTo(new JsonPrimitive(1));
+    assertThat(list.get(0)).isEqualTo(new JsonPrimitive(2));
+    assertThat(a.get(0)).isEqualTo(new JsonPrimitive(2));
 
     try {
       list.set(-1, new JsonPrimitive(1));
@@ -79,7 +75,7 @@ public class JsonArrayAsListTest {
       list.set(0, null);
       fail();
     } catch (NullPointerException e) {
-      assertEquals("Element must be non-null", e.getMessage());
+      assertThat(e).hasMessageThat().isEqualTo("Element must be non-null");
     }
   }
 
@@ -91,8 +87,8 @@ public class JsonArrayAsListTest {
     List<JsonElement> list = a.asList();
     list.add(0, new JsonPrimitive(2));
     list.add(1, new JsonPrimitive(3));
-    assertTrue(list.add(new JsonPrimitive(4)));
-    assertTrue(list.add(JsonNull.INSTANCE));
+    assertThat(list.add(new JsonPrimitive(4))).isTrue();
+    assertThat(list.add(JsonNull.INSTANCE)).isTrue();
 
     List<JsonElement> expectedList = Arrays.<JsonElement>asList(
         new JsonPrimitive(2),
@@ -101,7 +97,7 @@ public class JsonArrayAsListTest {
         new JsonPrimitive(4),
         JsonNull.INSTANCE
     );
-    assertEquals(expectedList, list);
+    assertThat(list).isEqualTo(expectedList);
 
     try {
       list.set(-1, new JsonPrimitive(1));
@@ -119,13 +115,13 @@ public class JsonArrayAsListTest {
       list.add(0, null);
       fail();
     } catch (NullPointerException e) {
-      assertEquals("Element must be non-null", e.getMessage());
+      assertThat(e).hasMessageThat().isEqualTo("Element must be non-null");
     }
     try {
       list.add(null);
       fail();
     } catch (NullPointerException e) {
-      assertEquals("Element must be non-null", e.getMessage());
+      assertThat(e).hasMessageThat().isEqualTo("Element must be non-null");
     }
   }
 
@@ -142,19 +138,20 @@ public class JsonArrayAsListTest {
         new JsonPrimitive(2),
         new JsonPrimitive(3)
     );
-    assertEquals(expectedList, list);
+    assertThat(list).isEqualTo(expectedList);
+    assertThat(list).isEqualTo(expectedList);
 
     try {
       list.addAll(0, Collections.<JsonElement>singletonList(null));
       fail();
     } catch (NullPointerException e) {
-      assertEquals("Element must be non-null", e.getMessage());
+      assertThat(e).hasMessageThat().isEqualTo("Element must be non-null");
     }
     try {
       list.addAll(Collections.<JsonElement>singletonList(null));
       fail();
     } catch (NullPointerException e) {
-      assertEquals("Element must be non-null", e.getMessage());
+      assertThat(e).hasMessageThat().isEqualTo("Element must be non-null");
     }
   }
 
@@ -164,10 +161,9 @@ public class JsonArrayAsListTest {
     a.add(1);
 
     List<JsonElement> list = a.asList();
-    assertEquals(new JsonPrimitive(1), list.remove(0));
-    assertEquals(0, list.size());
-    assertEquals(0, a.size());
-
+    assertThat(list.remove(0)).isEqualTo(new JsonPrimitive(1));
+    assertThat(list).hasSize(0);
+    assertThat(a).hasSize(0);
     try {
       list.remove(0);
       fail();
@@ -181,12 +177,12 @@ public class JsonArrayAsListTest {
     a.add(1);
 
     List<JsonElement> list = a.asList();
-    assertTrue(list.remove(new JsonPrimitive(1)));
-    assertEquals(0, list.size());
-    assertEquals(0, a.size());
+    assertThat(list.remove(new JsonPrimitive(1))).isTrue();
+    assertThat(list).hasSize(0);
+    assertThat(a).hasSize(0);
 
-    assertFalse(list.remove(new JsonPrimitive(1)));
-    assertFalse(list.remove(null));
+    assertThat(list.remove(new JsonPrimitive(1))).isFalse();
+    assertThat(list.remove(null)).isFalse();
   }
 
   @Test
@@ -196,8 +192,8 @@ public class JsonArrayAsListTest {
 
     List<JsonElement> list = a.asList();
     list.clear();
-    assertEquals(0, list.size());
-    assertEquals(0, a.size());
+    assertThat(list).hasSize(0);
+    assertThat(a).hasSize(0);
   }
 
   @Test
@@ -206,13 +202,13 @@ public class JsonArrayAsListTest {
     a.add(1);
 
     List<JsonElement> list = a.asList();
-    assertTrue(list.contains(new JsonPrimitive(1)));
-    assertFalse(list.contains(new JsonPrimitive(2)));
-    assertFalse(list.contains(null));
+    assertThat(list.contains(new JsonPrimitive(1))).isTrue();
+    assertThat(list.contains(new JsonPrimitive(2))).isFalse();
+    assertThat(list.contains(null)).isFalse();
 
     @SuppressWarnings({"unlikely-arg-type", "CollectionIncompatibleType"})
     boolean containsInt = list.contains(1); // should only contain JsonPrimitive(1)
-    assertFalse(containsInt);
+    assertThat(containsInt).isFalse();
   }
 
   @Test
@@ -223,17 +219,17 @@ public class JsonArrayAsListTest {
     a.add(1);
 
     List<JsonElement> list = a.asList();
-    assertEquals(0, list.indexOf(new JsonPrimitive(1)));
-    assertEquals(-1, list.indexOf(new JsonPrimitive(2)));
-    assertEquals(-1, list.indexOf(null));
+    assertThat(list.indexOf(new JsonPrimitive(1))).isEqualTo(0);
+    assertThat(list.indexOf(new JsonPrimitive(2))).isEqualTo(-1);
+    assertThat(list.indexOf(null)).isEqualTo(-1);
 
     @SuppressWarnings({"unlikely-arg-type", "CollectionIncompatibleType"})
     int indexOfInt = list.indexOf(1); // should only contain JsonPrimitive(1)
-    assertEquals(-1, indexOfInt);
+    assertThat(indexOfInt).isEqualTo(-1);
 
-    assertEquals(1, list.lastIndexOf(new JsonPrimitive(1)));
-    assertEquals(-1, list.lastIndexOf(new JsonPrimitive(2)));
-    assertEquals(-1, list.lastIndexOf(null));
+    assertThat(list.lastIndexOf(new JsonPrimitive(1))).isEqualTo(1);
+    assertThat(list.lastIndexOf(new JsonPrimitive(2))).isEqualTo(-1);
+    assertThat(list.lastIndexOf(null)).isEqualTo(-1);
   }
 
   @Test
@@ -242,19 +238,19 @@ public class JsonArrayAsListTest {
     a.add(1);
 
     List<JsonElement> list = a.asList();
-    assertArrayEquals(new Object[] {new JsonPrimitive(1)}, list.toArray());
+    assertThat(list.toArray()).isEqualTo(new Object[] {new JsonPrimitive(1)});
 
     JsonElement[] array = list.toArray(new JsonElement[0]);
-    assertArrayEquals(new Object[] {new JsonPrimitive(1)}, array);
+    assertThat(array).isEqualTo(new Object[] {new JsonPrimitive(1)});
 
     array = new JsonElement[1];
-    assertSame(array, list.toArray(array));
-    assertArrayEquals(new Object[] {new JsonPrimitive(1)}, array);
+    assertThat(list.toArray(array)).isEqualTo(array);
+    assertThat(array).isEqualTo(new Object[] {new JsonPrimitive(1)});
 
     array = new JsonElement[] {null, new JsonPrimitive(2)};
-    assertSame(array, list.toArray(array));
+    assertThat(list.toArray(array)).isEqualTo(array);
     // Should have set existing array element to null
-    assertArrayEquals(new Object[] {new JsonPrimitive(1), null}, array);
+    assertThat(array).isEqualTo(new Object[] {new JsonPrimitive(1), null});
   }
 
   @Test
@@ -264,8 +260,8 @@ public class JsonArrayAsListTest {
 
     List<JsonElement> list = a.asList();
     MoreAsserts.assertEqualsAndHashCode(list, Collections.singletonList(new JsonPrimitive(1)));
-    assertFalse(list.equals(Collections.emptyList()));
-    assertFalse(list.equals(Collections.singletonList(new JsonPrimitive(2))));
+    assertThat(list.equals(Collections.emptyList())).isFalse();
+    assertThat(list.equals(Collections.singletonList(new JsonPrimitive(2)))).isFalse();
   }
 
   /** Verify that {@code JsonArray} updates are visible to view and vice versa */
@@ -275,11 +271,11 @@ public class JsonArrayAsListTest {
     List<JsonElement> list = a.asList();
 
     a.add(1);
-    assertEquals(1, list.size());
-    assertEquals(new JsonPrimitive(1), list.get(0));
+    assertThat(list).hasSize(1);
+    assertThat(list.get(0)).isEqualTo(new JsonPrimitive(1));
 
     list.add(new JsonPrimitive(2));
-    assertEquals(2, a.size());
-    assertEquals(new JsonPrimitive(2), a.get(1));
+    assertThat(a).hasSize(2);
+    assertThat(a.get(1)).isEqualTo(new JsonPrimitive(2));
   }
 }
diff --git a/gson/src/test/java/com/google/gson/JsonArrayTest.java b/gson/src/test/java/com/google/gson/JsonArrayTest.java
index 45070e3f..c1103bec 100644
--- a/gson/src/test/java/com/google/gson/JsonArrayTest.java
+++ b/gson/src/test/java/com/google/gson/JsonArrayTest.java
@@ -16,9 +16,8 @@
 
 package com.google.gson;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+import static com.google.common.truth.Truth.assertThat;
+import static com.google.common.truth.Truth.assertWithMessage;
 import static org.junit.Assert.fail;
 
 import com.google.gson.common.MoreAsserts;
@@ -40,22 +39,22 @@ public final class JsonArrayTest {
     JsonArray a = new JsonArray();
     JsonArray b = new JsonArray();
 
-    assertEquals(a, a);
+    assertThat(a).isEqualTo(a);
 
     a.add(new JsonObject());
-    assertFalse(a.equals(b));
-    assertFalse(b.equals(a));
+    assertThat(a.equals(b)).isFalse();
+    assertThat(b.equals(a)).isFalse();
 
     b.add(new JsonObject());
     MoreAsserts.assertEqualsAndHashCode(a, b);
 
     a.add(new JsonObject());
-    assertFalse(a.equals(b));
-    assertFalse(b.equals(a));
+    assertThat(a.equals(b)).isFalse();
+    assertThat(b.equals(a)).isFalse();
 
     b.add(JsonNull.INSTANCE);
-    assertFalse(a.equals(b));
-    assertFalse(b.equals(a));
+    assertThat(a.equals(b)).isFalse();
+    assertThat(b.equals(a)).isFalse();
   }
 
   @Test
@@ -67,13 +66,13 @@ public final class JsonArrayTest {
     } catch (IndexOutOfBoundsException expected) {}
     JsonPrimitive a = new JsonPrimitive("a");
     array.add(a);
-    assertTrue(array.remove(a));
-    assertFalse(array.contains(a));
+    assertThat(array.remove(a)).isTrue();
+    assertThat(array.contains(a)).isFalse();
     array.add(a);
     array.add(new JsonPrimitive("b"));
-    assertEquals("b", array.remove(1).getAsString());
-    assertEquals(1, array.size());
-    assertTrue(array.contains(a));
+    assertThat(array.remove(1).getAsString()).isEqualTo("b");
+    assertThat(array).hasSize(1);
+    assertThat(array.contains(a)).isTrue();
   }
 
   @Test
@@ -88,17 +87,17 @@ public final class JsonArrayTest {
 
     JsonPrimitive b = new JsonPrimitive("b");
     JsonElement oldValue = array.set(0, b);
-    assertEquals(a, oldValue);
-    assertEquals("b", array.get(0).getAsString());
+    assertThat(oldValue).isEqualTo(a);
+    assertThat(array.get(0).getAsString()).isEqualTo("b");
 
     oldValue = array.set(0, null);
-    assertEquals(b, oldValue);
-    assertEquals(JsonNull.INSTANCE, array.get(0));
+    assertThat(oldValue).isEqualTo(b);
+    assertThat(array.get(0)).isEqualTo(JsonNull.INSTANCE);
 
     oldValue = array.set(0, new JsonPrimitive("c"));
-    assertEquals(JsonNull.INSTANCE, oldValue);
-    assertEquals("c", array.get(0).getAsString());
-    assertEquals(1, array.size());
+    assertThat(oldValue).isEqualTo(JsonNull.INSTANCE);
+    assertThat(array.get(0).getAsString()).isEqualTo("c");
+    assertThat(array).hasSize(1);
   }
 
   @Test
@@ -110,24 +109,24 @@ public final class JsonArrayTest {
     JsonArray copy = original.deepCopy();
     original.add(new JsonPrimitive("y"));
 
-    assertEquals(1, copy.size());
+    assertThat(copy).hasSize(1);
     firstEntry.add(new JsonPrimitive("z"));
 
-    assertEquals(1, original.get(0).getAsJsonArray().size());
-    assertEquals(0, copy.get(0).getAsJsonArray().size());
+    assertThat(original.get(0).getAsJsonArray()).hasSize(1);
+    assertThat(copy.get(0).getAsJsonArray()).hasSize(0);
   }
 
   @Test
   public void testIsEmpty() {
     JsonArray array = new JsonArray();
-    assertTrue(array.isEmpty());
+    assertThat(array).isEmpty();
 
     JsonPrimitive a = new JsonPrimitive("a");
     array.add(a);
-    assertFalse(array.isEmpty());
+    assertThat(array).isNotEmpty();
 
     array.remove(0);
-    assertTrue(array.isEmpty());
+    assertThat(array).isEmpty();
   }
 
   @Test
@@ -138,22 +137,22 @@ public final class JsonArrayTest {
       jsonArray.getAsBoolean();
       fail("expected getBoolean to fail");
     } catch (UnsupportedOperationException e) {
-      assertEquals("Expected an exception message",
-              "JsonObject", e.getMessage());
+      assertWithMessage("Expected an exception message")
+          .that(e).hasMessageThat().isEqualTo("JsonObject");
     }
     try {
       jsonArray.get(-1);
       fail("expected get to fail");
     } catch (IndexOutOfBoundsException e) {
-      assertEquals("Expected an exception message",
-              "Index -1 out of bounds for length 1", e.getMessage());
+      assertWithMessage("Expected an exception message")
+          .that(e).hasMessageThat().isEqualTo("Index -1 out of bounds for length 1");
     }
     try {
       jsonArray.getAsString();
       fail("expected getString to fail");
     } catch (UnsupportedOperationException e) {
-      assertEquals("Expected an exception message",
-              "JsonObject", e.getMessage());
+      assertWithMessage("Expected an exception message")
+          .that(e).hasMessageThat().isEqualTo("JsonObject");
     }
 
     jsonArray.remove(0);
@@ -162,36 +161,36 @@ public final class JsonArrayTest {
       jsonArray.getAsDouble();
       fail("expected getDouble to fail");
     } catch (NumberFormatException e) {
-      assertEquals("Expected an exception message",
-              "For input string: \"hello\"", e.getMessage());
+      assertWithMessage("Expected an exception message")
+          .that(e).hasMessageThat().isEqualTo("For input string: \"hello\"");
     }
     try {
       jsonArray.getAsInt();
       fail("expected getInt to fail");
     } catch (NumberFormatException e) {
-      assertEquals("Expected an exception message",
-              "For input string: \"hello\"", e.getMessage());
+      assertWithMessage("Expected an exception message")
+          .that(e).hasMessageThat().isEqualTo("For input string: \"hello\"");
     }
     try {
       jsonArray.get(0).getAsJsonArray();
       fail("expected getJSONArray to fail");
     } catch (IllegalStateException e) {
-      assertEquals("Expected an exception message",
-              "Not a JSON Array: \"hello\"", e.getMessage());
+      assertWithMessage("Expected an exception message")
+          .that(e).hasMessageThat().isEqualTo("Not a JSON Array: \"hello\"");
     }
     try {
       jsonArray.getAsJsonObject();
       fail("expected getJSONObject to fail");
     } catch (IllegalStateException e) {
-      assertEquals("Expected an exception message",
-              "Not a JSON Object: [\"hello\"]", e.getMessage());
+      assertWithMessage("Expected an exception message")
+          .that(e).hasMessageThat().isEqualTo( "Not a JSON Object: [\"hello\"]");
     }
     try {
       jsonArray.getAsLong();
       fail("expected getLong to fail");
     } catch (NumberFormatException e) {
-      assertEquals("Expected an exception message",
-              "For input string: \"hello\"", e.getMessage());
+      assertWithMessage("Expected an exception message")
+          .that(e).hasMessageThat().isEqualTo("For input string: \"hello\"");
     }
   }
 
@@ -202,7 +201,7 @@ public final class JsonArrayTest {
       jsonArray.getAsByte();
       fail();
     } catch (IllegalStateException e) {
-      assertEquals("Array must have size 1, but has size 0", e.getMessage());
+      assertThat(e).hasMessageThat().isEqualTo("Array must have size 1, but has size 0");
     }
 
     jsonArray.add(true);
@@ -211,7 +210,7 @@ public final class JsonArrayTest {
       jsonArray.getAsByte();
       fail();
     } catch (IllegalStateException e) {
-      assertEquals("Array must have size 1, but has size 2", e.getMessage());
+      assertThat(e).hasMessageThat().isEqualTo("Array must have size 1, but has size 2");
     }
   }
 
@@ -225,7 +224,7 @@ public final class JsonArrayTest {
     jsonArray.add((String) null);
     jsonArray.add("Yes");
 
-    assertEquals("[\"Hello\",\"Goodbye\",\"Thank you\",null,\"Yes\"]", jsonArray.toString());
+    assertThat(jsonArray.toString()).isEqualTo("[\"Hello\",\"Goodbye\",\"Thank you\",null,\"Yes\"]");
   }
 
   @Test
@@ -249,7 +248,7 @@ public final class JsonArrayTest {
     x = 0;
     jsonArray.add(x);
 
-    assertEquals("[1,2,-3,null,4,0]", jsonArray.toString());
+    assertThat(jsonArray.toString()).isEqualTo("[1,2,-3,null,4,0]");
   }
 
   @Test
@@ -272,7 +271,7 @@ public final class JsonArrayTest {
 
     jsonArray.add((Double) null);
 
-    assertEquals("[1.0,2.13232,0.121,null,-0.00234,null]", jsonArray.toString());
+    assertThat(jsonArray.toString()).isEqualTo("[1.0,2.13232,0.121,null,-0.00234,null]");
   }
 
   @Test
@@ -286,7 +285,7 @@ public final class JsonArrayTest {
     jsonArray.add((Boolean) null);
     jsonArray.add(true);
 
-    assertEquals("[true,true,false,false,null,true]", jsonArray.toString());
+    assertThat(jsonArray.toString()).isEqualTo("[true,true,false,false,null,true]");
   }
 
   @Test
@@ -301,7 +300,7 @@ public final class JsonArrayTest {
     jsonArray.add('u');
     jsonArray.add("and sometimes Y");
 
-    assertEquals("[\"a\",\"e\",\"i\",\"o\",null,\"u\",\"and sometimes Y\"]", jsonArray.toString());
+    assertThat(jsonArray.toString()).isEqualTo("[\"a\",\"e\",\"i\",\"o\",null,\"u\",\"and sometimes Y\"]");
   }
 
   @Test
@@ -314,15 +313,15 @@ public final class JsonArrayTest {
     jsonArray.add((char) 111);
 
     jsonArray.add((Boolean) null);
-    assertEquals(JsonNull.INSTANCE, jsonArray.get(jsonArray.size() - 1));
+    assertThat(jsonArray.get(jsonArray.size() - 1)).isEqualTo(JsonNull.INSTANCE);
 
     jsonArray.add((Character) null);
-    assertEquals(JsonNull.INSTANCE, jsonArray.get(jsonArray.size() - 1));
+    assertThat(jsonArray.get(jsonArray.size() - 1)).isEqualTo(JsonNull.INSTANCE);
 
     jsonArray.add(12.232);
     jsonArray.add(BigInteger.valueOf(2323));
 
-    assertEquals("[\"a\",\"apple\",12121,\"o\",null,null,12.232,2323]", jsonArray.toString());
+    assertThat(jsonArray.toString()).isEqualTo("[\"a\",\"apple\",12121,\"o\",null,null,12.232,2323]");
   }
 
   @Test
@@ -339,10 +338,10 @@ public final class JsonArrayTest {
     jsonArray.add((Boolean) null);
     jsonArray.add((Number) null);
 
-    assertEquals("[null,null,null,null,null,null,null,null,null]", jsonArray.toString());
+    assertThat(jsonArray.toString()).isEqualTo("[null,null,null,null,null,null,null,null,null]");
     for (int i = 0; i < jsonArray.size(); i++) {
       // Verify that they are actually a JsonNull and not a Java null
-      assertEquals(JsonNull.INSTANCE, jsonArray.get(i));
+      assertThat(jsonArray.get(i)).isEqualTo(JsonNull.INSTANCE);
     }
   }
 
@@ -350,7 +349,7 @@ public final class JsonArrayTest {
   public void testNullJsonElementAddition() {
     JsonArray jsonArray = new JsonArray();
     jsonArray.add((JsonElement) null);
-    assertEquals(JsonNull.INSTANCE, jsonArray.get(0));
+    assertThat(jsonArray.get(0)).isEqualTo(JsonNull.INSTANCE);
   }
 
   @Test
@@ -368,6 +367,6 @@ public final class JsonArrayTest {
     jsonArray.add((Boolean) null);
     jsonArray.add((Boolean) null);
 
-    assertEquals("[\"a\",\"a\",true,true,1212,1212,34.34,34.34,null,null]", jsonArray.toString());
+    assertThat(jsonArray.toString()).isEqualTo("[\"a\",\"a\",true,true,1212,1212,34.34,34.34,null,null]");
   }
 }
diff --git a/gson/src/test/java/com/google/gson/JsonNullTest.java b/gson/src/test/java/com/google/gson/JsonNullTest.java
index 6157e387..caaf0ad8 100644
--- a/gson/src/test/java/com/google/gson/JsonNullTest.java
+++ b/gson/src/test/java/com/google/gson/JsonNullTest.java
@@ -16,25 +16,29 @@
 
 package com.google.gson;
 
+import static com.google.common.truth.Truth.assertThat;
+
 import com.google.gson.common.MoreAsserts;
-import junit.framework.TestCase;
+import org.junit.Test;
 
 /**
  * @author Jesse Wilson
  */
-public final class JsonNullTest extends TestCase {
+public final class JsonNullTest {
 
   @SuppressWarnings("deprecation")
+  @Test
   public void testEqualsAndHashcode() {
     MoreAsserts.assertEqualsAndHashCode(new JsonNull(), new JsonNull());
     MoreAsserts.assertEqualsAndHashCode(new JsonNull(), JsonNull.INSTANCE);
     MoreAsserts.assertEqualsAndHashCode(JsonNull.INSTANCE, JsonNull.INSTANCE);
   }
 
+  @Test
   public void testDeepCopy() {
     @SuppressWarnings("deprecation")
     JsonNull a = new JsonNull();
-    assertSame(JsonNull.INSTANCE, a.deepCopy());
-    assertSame(JsonNull.INSTANCE, JsonNull.INSTANCE.deepCopy());
+    assertThat(a.deepCopy()).isSameInstanceAs(JsonNull.INSTANCE);
+    assertThat(JsonNull.INSTANCE.deepCopy()).isSameInstanceAs(JsonNull.INSTANCE);
   }
 }
diff --git a/gson/src/test/java/com/google/gson/JsonObjectAsMapTest.java b/gson/src/test/java/com/google/gson/JsonObjectAsMapTest.java
index 00a89a6f..0e4de073 100644
--- a/gson/src/test/java/com/google/gson/JsonObjectAsMapTest.java
+++ b/gson/src/test/java/com/google/gson/JsonObjectAsMapTest.java
@@ -1,9 +1,6 @@
 package com.google.gson;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
+import static com.google.common.truth.Truth.assertThat;
 import static org.junit.Assert.fail;
 
 import com.google.gson.common.MoreAsserts;
@@ -26,15 +23,15 @@ public class JsonObjectAsMapTest {
   @Test
   public void testSize() {
     JsonObject o = new JsonObject();
-    assertEquals(0, o.asMap().size());
+    assertThat(o.asMap().size()).isEqualTo(0);
 
     o.addProperty("a", 1);
     Map<String, JsonElement> map = o.asMap();
-    assertEquals(1, map.size());
+    assertThat(map).hasSize(1);
 
     map.clear();
-    assertEquals(0, map.size());
-    assertEquals(0, o.size());
+    assertThat(map).hasSize(0);
+    assertThat(o.size()).isEqualTo(0);
   }
 
   @Test
@@ -43,9 +40,9 @@ public class JsonObjectAsMapTest {
     o.addProperty("a", 1);
 
     Map<String, JsonElement> map = o.asMap();
-    assertTrue(map.containsKey("a"));
-    assertFalse(map.containsKey("b"));
-    assertFalse(map.containsKey(null));
+    assertThat(map.containsKey("a")).isTrue();
+    assertThat(map.containsKey("b")).isFalse();
+    assertThat(map.containsKey(null)).isFalse();
   }
 
   @Test
@@ -55,13 +52,13 @@ public class JsonObjectAsMapTest {
     o.add("b", JsonNull.INSTANCE);
 
     Map<String, JsonElement> map = o.asMap();
-    assertTrue(map.containsValue(new JsonPrimitive(1)));
-    assertFalse(map.containsValue(new JsonPrimitive(2)));
-    assertFalse(map.containsValue(null));
+    assertThat(map.containsValue(new JsonPrimitive(1))).isTrue();
+    assertThat(map.containsValue(new JsonPrimitive(2))).isFalse();
+    assertThat(map.containsValue(null)).isFalse();
 
     @SuppressWarnings({"unlikely-arg-type", "CollectionIncompatibleType"})
     boolean containsInt = map.containsValue(1); // should only contain JsonPrimitive(1)
-    assertFalse(containsInt);
+    assertThat(containsInt).isFalse();
   }
 
   @Test
@@ -70,9 +67,9 @@ public class JsonObjectAsMapTest {
     o.addProperty("a", 1);
 
     Map<String, JsonElement> map = o.asMap();
-    assertEquals(new JsonPrimitive(1), map.get("a"));
-    assertNull(map.get("b"));
-    assertNull(map.get(null));
+    assertThat(map.get("a")).isEqualTo(new JsonPrimitive(1));
+    assertThat(map.get("b")).isNull();
+    assertThat(map.get(null)).isNull();
   }
 
   @Test
@@ -80,31 +77,30 @@ public class JsonObjectAsMapTest {
     JsonObject o = new JsonObject();
     Map<String, JsonElement> map = o.asMap();
 
-    assertNull(map.put("a", new JsonPrimitive(1)));
-    assertEquals(1, map.size());
-    assertEquals(new JsonPrimitive(1), map.get("a"));
+    assertThat(map.put("a", new JsonPrimitive(1))).isNull();
+    assertThat(map.get("a")).isEqualTo(new JsonPrimitive(1));
 
     JsonElement old = map.put("a", new JsonPrimitive(2));
-    assertEquals(new JsonPrimitive(1), old);
-    assertEquals(1, map.size());
-    assertEquals(new JsonPrimitive(2), map.get("a"));
-    assertEquals(new JsonPrimitive(2), o.get("a"));
+    assertThat(old).isEqualTo(new JsonPrimitive(1));
+    assertThat(map).hasSize(1);
+    assertThat(map.get("a")).isEqualTo(new JsonPrimitive(2));
+    assertThat(o.get("a")).isEqualTo(new JsonPrimitive(2));
 
-    assertNull(map.put("b", JsonNull.INSTANCE));
-    assertEquals(JsonNull.INSTANCE, map.get("b"));
+    assertThat(map.put("b", JsonNull.INSTANCE)).isNull();
+    assertThat(map.get("b")).isEqualTo(JsonNull.INSTANCE);
 
     try {
       map.put(null, new JsonPrimitive(1));
       fail();
     } catch (NullPointerException e) {
-      assertEquals("key == null", e.getMessage());
+      assertThat(e).hasMessageThat().isEqualTo("key == null");
     }
 
     try {
       map.put("a", null);
       fail();
     } catch (NullPointerException e) {
-      assertEquals("value == null", e.getMessage());
+      assertThat(e).hasMessageThat().isEqualTo("value == null");
     }
   }
 
@@ -114,18 +110,18 @@ public class JsonObjectAsMapTest {
     o.addProperty("a", 1);
 
     Map<String, JsonElement> map = o.asMap();
-    assertNull(map.remove("b"));
-    assertEquals(1, map.size());
+    assertThat(map.remove("b")).isNull();
+    assertThat(map).hasSize(1);
 
     JsonElement old = map.remove("a");
-    assertEquals(new JsonPrimitive(1), old);
-    assertEquals(0, map.size());
+    assertThat(old).isEqualTo(new JsonPrimitive(1));
+    assertThat(map).hasSize(0);
 
-    assertNull(map.remove("a"));
-    assertEquals(0, map.size());
-    assertEquals(0, o.size());
+    assertThat(map.remove("a")).isNull();
+    assertThat(map).hasSize(0);
+    assertThat(o.size()).isEqualTo(0);
 
-    assertNull(map.remove(null));
+    assertThat(map.remove(null)).isNull();
   }
 
   @Test
@@ -139,22 +135,22 @@ public class JsonObjectAsMapTest {
 
     Map<String, JsonElement> map = o.asMap();
     map.putAll(otherMap);
-    assertEquals(2, map.size());
-    assertEquals(new JsonPrimitive(2), map.get("a"));
-    assertEquals(new JsonPrimitive(3), map.get("b"));
+    assertThat(map).hasSize(2);
+    assertThat(map.get("a")).isEqualTo(new JsonPrimitive(2));
+    assertThat(map.get("b")).isEqualTo(new JsonPrimitive(3));
 
     try {
       map.putAll(Collections.<String, JsonElement>singletonMap(null, new JsonPrimitive(1)));
       fail();
     } catch (NullPointerException e) {
-      assertEquals("key == null", e.getMessage());
+      assertThat(e).hasMessageThat().isEqualTo("key == null");
     }
 
     try {
       map.putAll(Collections.<String, JsonElement>singletonMap("a", null));
       fail();
     } catch (NullPointerException e) {
-      assertEquals("value == null", e.getMessage());
+      assertThat(e).hasMessageThat().isEqualTo("value == null");
     }
   }
 
@@ -165,8 +161,8 @@ public class JsonObjectAsMapTest {
 
     Map<String, JsonElement> map = o.asMap();
     map.clear();
-    assertEquals(0, map.size());
-    assertEquals(0, o.size());
+    assertThat(map).hasSize(0);
+    assertThat(o.size()).isEqualTo(0);
   }
 
   @Test
@@ -178,7 +174,7 @@ public class JsonObjectAsMapTest {
     Map<String, JsonElement> map = o.asMap();
     Set<String> keySet = map.keySet();
     // Should contain keys in same order
-    assertEquals(Arrays.asList("b", "a"), new ArrayList<>(keySet));
+    assertThat(keySet).containsExactly("b", "a").inOrder();
 
     // Key set doesn't support insertions
     try {
@@ -187,9 +183,9 @@ public class JsonObjectAsMapTest {
     } catch (UnsupportedOperationException e) {
     }
 
-    assertTrue(keySet.remove("a"));
-    assertEquals(Collections.singleton("b"), map.keySet());
-    assertEquals(Collections.singleton("b"), o.keySet());
+    assertThat(keySet.remove("a")).isTrue();
+    assertThat(map.keySet()).isEqualTo(Collections.singleton("b"));
+    assertThat(o.keySet()).isEqualTo(Collections.singleton("b"));
   }
 
   @Test
@@ -201,7 +197,7 @@ public class JsonObjectAsMapTest {
     Map<String, JsonElement> map = o.asMap();
     Collection<JsonElement> values = map.values();
     // Should contain values in same order
-    assertEquals(Arrays.asList(new JsonPrimitive(2), new JsonPrimitive(1)), new ArrayList<>(values));
+    assertThat(values).containsExactly(new JsonPrimitive(2), new JsonPrimitive(1)).inOrder();
 
     // Values collection doesn't support insertions
     try {
@@ -210,10 +206,10 @@ public class JsonObjectAsMapTest {
     } catch (UnsupportedOperationException e) {
     }
 
-    assertTrue(values.remove(new JsonPrimitive(2)));
-    assertEquals(Collections.singletonList(new JsonPrimitive(1)), new ArrayList<>(map.values()));
-    assertEquals(1, o.size());
-    assertEquals(new JsonPrimitive(1), o.get("b"));
+    assertThat(values.remove(new JsonPrimitive(2))).isTrue();
+    assertThat(new ArrayList<>(map.values())).isEqualTo(Collections.singletonList(new JsonPrimitive(1)));
+    assertThat(o.size()).isEqualTo(1);
+    assertThat(o.get("b")).isEqualTo(new JsonPrimitive(1));
   }
 
   @Test
@@ -230,7 +226,7 @@ public class JsonObjectAsMapTest {
         new SimpleEntry<>("a", new JsonPrimitive(1))
     );
     // Should contain entries in same order
-    assertEquals(expectedEntrySet, new ArrayList<>(entrySet));
+    assertThat(new ArrayList<>(entrySet)).isEqualTo(expectedEntrySet);
 
     try {
       entrySet.add(new SimpleEntry<String, JsonElement>("c", new JsonPrimitive(3)));
@@ -238,24 +234,24 @@ public class JsonObjectAsMapTest {
     } catch (UnsupportedOperationException e) {
     }
 
-    assertTrue(entrySet.remove(new SimpleEntry<>("a", new JsonPrimitive(1))));
-    assertEquals(Collections.singleton(new SimpleEntry<>("b", new JsonPrimitive(2))), map.entrySet());
-    assertEquals(Collections.singleton(new SimpleEntry<>("b", new JsonPrimitive(2))), o.entrySet());
+    assertThat(entrySet.remove(new SimpleEntry<>("a", new JsonPrimitive(1)))).isTrue();
+    assertThat(map.entrySet()).isEqualTo(Collections.singleton(new SimpleEntry<>("b", new JsonPrimitive(2))));
+    assertThat(o.entrySet()).isEqualTo(Collections.singleton(new SimpleEntry<>("b", new JsonPrimitive(2))));
 
     // Should return false because entry has already been removed
-    assertFalse(entrySet.remove(new SimpleEntry<>("a", new JsonPrimitive(1))));
+    assertThat(entrySet.remove(new SimpleEntry<>("a", new JsonPrimitive(1)))).isFalse();
 
     Entry<String, JsonElement> entry = entrySet.iterator().next();
     JsonElement old = entry.setValue(new JsonPrimitive(3));
-    assertEquals(new JsonPrimitive(2), old);
-    assertEquals(Collections.singleton(new SimpleEntry<>("b", new JsonPrimitive(3))), map.entrySet());
-    assertEquals(Collections.singleton(new SimpleEntry<>("b", new JsonPrimitive(3))), o.entrySet());
+    assertThat(old).isEqualTo(new JsonPrimitive(2));
+    assertThat(map.entrySet()).isEqualTo(Collections.singleton(new SimpleEntry<>("b", new JsonPrimitive(3))));
+    assertThat(o.entrySet()).isEqualTo(Collections.singleton(new SimpleEntry<>("b", new JsonPrimitive(3))));
 
     try {
       entry.setValue(null);
       fail();
     } catch (NullPointerException e) {
-      assertEquals("value == null", e.getMessage());
+      assertThat(e).hasMessageThat().isEqualTo("value == null");
     }
   }
 
@@ -266,8 +262,8 @@ public class JsonObjectAsMapTest {
 
     Map<String, JsonElement> map = o.asMap();
     MoreAsserts.assertEqualsAndHashCode(map, Collections.singletonMap("a", new JsonPrimitive(1)));
-    assertFalse(map.equals(Collections.emptyMap()));
-    assertFalse(map.equals(Collections.singletonMap("a", new JsonPrimitive(2))));
+    assertThat(map.equals(Collections.emptyMap())).isFalse();
+    assertThat(map.equals(Collections.singletonMap("a", new JsonPrimitive(2)))).isFalse();
   }
 
   /** Verify that {@code JsonObject} updates are visible to view and vice versa */
@@ -277,11 +273,11 @@ public class JsonObjectAsMapTest {
     Map<String, JsonElement> map = o.asMap();
 
     o.addProperty("a", 1);
-    assertEquals(1, map.size());
-    assertEquals(new JsonPrimitive(1), map.get("a"));
+    assertThat(map).hasSize(1);
+    assertThat(map.get("a")).isEqualTo(new JsonPrimitive(1));
 
     map.put("b", new JsonPrimitive(2));
-    assertEquals(2, o.size());
-    assertEquals(new JsonPrimitive(2), o.get("b"));
+    assertThat(o.size()).isEqualTo(2);
+    assertThat(map.get("b")).isEqualTo(new JsonPrimitive(2));
   }
 }
diff --git a/gson/src/test/java/com/google/gson/JsonObjectTest.java b/gson/src/test/java/com/google/gson/JsonObjectTest.java
index 6e1339c7..d26afc4b 100644
--- a/gson/src/test/java/com/google/gson/JsonObjectTest.java
+++ b/gson/src/test/java/com/google/gson/JsonObjectTest.java
@@ -16,11 +16,7 @@
 
 package com.google.gson;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
+import static com.google.common.truth.Truth.assertThat;
 import static org.junit.Assert.fail;
 
 import com.google.gson.common.MoreAsserts;
@@ -44,39 +40,39 @@ import org.junit.Test;
 public class JsonObjectTest {
 
   @Test
-  public void testAddingAndRemovingObjectProperties() throws Exception {
+  public void testAddingAndRemovingObjectProperties() {
     JsonObject jsonObj = new JsonObject();
     String propertyName = "property";
-    assertFalse(jsonObj.has(propertyName));
-    assertNull(jsonObj.get(propertyName));
+    assertThat(jsonObj.has(propertyName)).isFalse();
+    assertThat(jsonObj.get(propertyName)).isNull();
 
     JsonPrimitive value = new JsonPrimitive("blah");
     jsonObj.add(propertyName, value);
-    assertEquals(value, jsonObj.get(propertyName));
+    assertThat(jsonObj.get(propertyName)).isEqualTo(value);
 
     JsonElement removedElement = jsonObj.remove(propertyName);
-    assertEquals(value, removedElement);
-    assertFalse(jsonObj.has(propertyName));
-    assertNull(jsonObj.get(propertyName));
+    assertThat(removedElement).isEqualTo(value);
+    assertThat(jsonObj.has(propertyName)).isFalse();
+    assertThat(jsonObj.get(propertyName)).isNull();
 
-    assertNull(jsonObj.remove(propertyName));
+    assertThat(jsonObj.remove(propertyName)).isNull();
   }
 
   @Test
-  public void testAddingNullPropertyValue() throws Exception {
+  public void testAddingNullPropertyValue() {
     String propertyName = "property";
     JsonObject jsonObj = new JsonObject();
     jsonObj.add(propertyName, null);
 
-    assertTrue(jsonObj.has(propertyName));
+    assertThat(jsonObj.has(propertyName)).isTrue();
 
     JsonElement jsonElement = jsonObj.get(propertyName);
-    assertNotNull(jsonElement);
-    assertTrue(jsonElement.isJsonNull());
+    assertThat(jsonElement).isNotNull();
+    assertThat(jsonElement.isJsonNull()).isTrue();
   }
 
   @Test
-  public void testAddingNullOrEmptyPropertyName() throws Exception {
+  public void testAddingNullOrEmptyPropertyName() {
     JsonObject jsonObj = new JsonObject();
     try {
       jsonObj.add(null, JsonNull.INSTANCE);
@@ -88,50 +84,50 @@ public class JsonObjectTest {
   }
 
   @Test
-  public void testAddingBooleanProperties() throws Exception {
+  public void testAddingBooleanProperties() {
     String propertyName = "property";
     JsonObject jsonObj = new JsonObject();
     jsonObj.addProperty(propertyName, true);
 
-    assertTrue(jsonObj.has(propertyName));
+    assertThat(jsonObj.has(propertyName)).isTrue();
 
     JsonElement jsonElement = jsonObj.get(propertyName);
-    assertNotNull(jsonElement);
-    assertTrue(jsonElement.getAsBoolean());
+    assertThat(jsonElement).isNotNull();
+    assertThat(jsonElement.getAsBoolean()).isTrue();
   }
 
   @Test
-  public void testAddingStringProperties() throws Exception {
+  public void testAddingStringProperties() {
     String propertyName = "property";
     String value = "blah";
 
     JsonObject jsonObj = new JsonObject();
     jsonObj.addProperty(propertyName, value);
 
-    assertTrue(jsonObj.has(propertyName));
+    assertThat(jsonObj.has(propertyName)).isTrue();
 
     JsonElement jsonElement = jsonObj.get(propertyName);
-    assertNotNull(jsonElement);
-    assertEquals(value, jsonElement.getAsString());
+    assertThat(jsonElement).isNotNull();
+    assertThat(jsonElement.getAsString()).isEqualTo(value);
   }
 
   @Test
-  public void testAddingCharacterProperties() throws Exception {
+  public void testAddingCharacterProperties() {
     String propertyName = "property";
     char value = 'a';
 
     JsonObject jsonObj = new JsonObject();
     jsonObj.addProperty(propertyName, value);
 
-    assertTrue(jsonObj.has(propertyName));
+    assertThat(jsonObj.has(propertyName)).isTrue();
 
     JsonElement jsonElement = jsonObj.get(propertyName);
-    assertNotNull(jsonElement);
-    assertEquals(String.valueOf(value), jsonElement.getAsString());
+    assertThat(jsonElement).isNotNull();
+    assertThat(jsonElement.getAsString()).isEqualTo(String.valueOf(value));
 
     @SuppressWarnings("deprecation")
     char character = jsonElement.getAsCharacter();
-    assertEquals(value, character);
+    assertThat(character).isEqualTo(value);
   }
 
   /**
@@ -142,7 +138,7 @@ public class JsonObjectTest {
     JsonObject jsonObj = new JsonObject();
     jsonObj.add("a\"b", new JsonPrimitive("c\"d"));
     String json = new Gson().toJson(jsonObj);
-    assertEquals("{\"a\\\"b\":\"c\\\"d\"}", json);
+    assertThat(json).isEqualTo("{\"a\\\"b\":\"c\\\"d\"}");
   }
 
   /**
@@ -152,14 +148,13 @@ public class JsonObjectTest {
   public void testWritePropertyWithEmptyStringName() {
     JsonObject jsonObj = new JsonObject();
     jsonObj.add("", new JsonPrimitive(true));
-    assertEquals("{\"\":true}", new Gson().toJson(jsonObj));
-
+    assertThat(new Gson().toJson(jsonObj)).isEqualTo("{\"\":true}");
   }
 
   @Test
   public void testReadPropertyWithEmptyStringName() {
     JsonObject jsonObj = JsonParser.parseString("{\"\":true}").getAsJsonObject();
-    assertEquals(true, jsonObj.get("").getAsBoolean());
+    assertThat(jsonObj.get("").getAsBoolean()).isTrue();
   }
 
   @Test
@@ -172,22 +167,22 @@ public class JsonObjectTest {
     JsonObject a = new JsonObject();
     JsonObject b = new JsonObject();
 
-    assertEquals(a, a);
+    assertThat(a).isEqualTo(a);
 
     a.add("foo", new JsonObject());
-    assertFalse(a.equals(b));
-    assertFalse(b.equals(a));
+    assertThat(a.equals(b)).isFalse();
+    assertThat(b.equals(a)).isFalse();
 
     b.add("foo", new JsonObject());
     MoreAsserts.assertEqualsAndHashCode(a, b);
 
     a.add("bar", new JsonObject());
-    assertFalse(a.equals(b));
-    assertFalse(b.equals(a));
+    assertThat(a.equals(b)).isFalse();
+    assertThat(b.equals(a)).isFalse();
 
     b.add("bar", JsonNull.INSTANCE);
-    assertFalse(a.equals(b));
-    assertFalse(b.equals(a));
+    assertThat(a.equals(b)).isFalse();
+    assertThat(b.equals(a)).isFalse();
   }
 
   @Test
@@ -201,8 +196,8 @@ public class JsonObjectTest {
     a.addProperty("2", false);
     b.addProperty("1", true);
 
-    assertEquals(Arrays.asList("1", "2"), new ArrayList<>(a.keySet()));
-    assertEquals(Arrays.asList("2", "1"), new ArrayList<>(b.keySet()));
+    assertThat(new ArrayList<>(a.keySet())).containsExactly("1", "2").inOrder();
+    assertThat(new ArrayList<>(b.keySet())).containsExactly("2", "1").inOrder();
 
     MoreAsserts.assertEqualsAndHashCode(a, b);
   }
@@ -210,28 +205,28 @@ public class JsonObjectTest {
   @Test
   public void testSize() {
     JsonObject o = new JsonObject();
-    assertEquals(0, o.size());
+    assertThat(o.size()).isEqualTo(0);
 
     o.add("Hello", new JsonPrimitive(1));
-    assertEquals(1, o.size());
+    assertThat(o.size()).isEqualTo(1);
 
     o.add("Hi", new JsonPrimitive(1));
-    assertEquals(2, o.size());
+    assertThat(o.size()).isEqualTo(2);
 
     o.remove("Hello");
-    assertEquals(1, o.size());
+    assertThat(o.size()).isEqualTo(1);
   }
 
   @Test
   public void testIsEmpty() {
     JsonObject o = new JsonObject();
-    assertTrue(o.isEmpty());
+    assertThat(o.isEmpty()).isTrue();
 
     o.add("Hello", new JsonPrimitive(1));
-    assertFalse(o.isEmpty());
+    assertThat(o.isEmpty()).isFalse();
 
     o.remove("Hello");
-    assertTrue(o.isEmpty());
+    assertThat(o.isEmpty()).isTrue();
   }
 
   @Test
@@ -243,8 +238,8 @@ public class JsonObjectTest {
     JsonObject copy = original.deepCopy();
     firstEntry.add(new JsonPrimitive("z"));
 
-    assertEquals(1, original.get("key").getAsJsonArray().size());
-    assertEquals(0, copy.get("key").getAsJsonArray().size());
+    assertThat(original.get("key").getAsJsonArray()).hasSize(1);
+    assertThat(copy.get("key").getAsJsonArray()).hasSize(0);
   }
 
   /**
@@ -253,15 +248,15 @@ public class JsonObjectTest {
   @Test
   public void testKeySet() {
     JsonObject a = new JsonObject();
-    assertEquals(0, a.keySet().size());
+    assertThat(a.keySet()).hasSize(0);
 
     a.add("foo", new JsonArray());
     a.add("bar", new JsonObject());
 
-    assertEquals(2, a.size());
-    assertEquals(2, a.keySet().size());
-    assertTrue(a.keySet().contains("foo"));
-    assertTrue(a.keySet().contains("bar"));
+    assertThat(a.size()).isEqualTo(2);
+    assertThat(a.keySet()).hasSize(2);
+    assertThat(a.keySet().contains("foo")).isTrue();
+    assertThat(a.keySet().contains("bar")).isTrue();
 
     a.addProperty("1", true);
     a.addProperty("2", false);
@@ -269,30 +264,30 @@ public class JsonObjectTest {
     // Insertion order should be preserved by keySet()
     Deque<String> expectedKeys = new ArrayDeque<>(Arrays.asList("foo", "bar", "1", "2"));
     // Note: Must wrap in ArrayList because Deque implementations do not implement `equals`
-    assertEquals(new ArrayList<>(expectedKeys), new ArrayList<>(a.keySet()));
+    assertThat(new ArrayList<>(a.keySet())).isEqualTo(new ArrayList<>(expectedKeys));
     Iterator<String> iterator = a.keySet().iterator();
 
     // Remove keys one by one
     for (int i = a.size(); i >= 1; i--) {
-      assertTrue(iterator.hasNext());
-      assertEquals(expectedKeys.getFirst(), iterator.next());
+      assertThat(iterator.hasNext()).isTrue();
+      assertThat(iterator.next()).isEqualTo(expectedKeys.getFirst());
       iterator.remove();
       expectedKeys.removeFirst();
 
-      assertEquals(i - 1, a.size());
-      assertEquals(new ArrayList<>(expectedKeys), new ArrayList<>(a.keySet()));
+      assertThat(a.size()).isEqualTo(i - 1);
+      assertThat(new ArrayList<>(a.keySet())).isEqualTo(new ArrayList<>(expectedKeys));
     }
   }
 
   @Test
   public void testEntrySet() {
     JsonObject o = new JsonObject();
-    assertEquals(0, o.entrySet().size());
+    assertThat(o.entrySet()).hasSize(0);
 
     o.addProperty("b", true);
     Set<?> expectedEntries = Collections.singleton(new SimpleEntry<>("b", new JsonPrimitive(true)));
-    assertEquals(expectedEntries, o.entrySet());
-    assertEquals(1, o.entrySet().size());
+    assertThat(o.entrySet()).isEqualTo(expectedEntries);
+    assertThat(o.entrySet()).hasSize(1);
 
     o.addProperty("a", false);
     // Insertion order should be preserved by entrySet()
@@ -300,7 +295,7 @@ public class JsonObjectTest {
         new SimpleEntry<>("b", new JsonPrimitive(true)),
         new SimpleEntry<>("a", new JsonPrimitive(false))
       );
-    assertEquals(expectedEntriesList, new ArrayList<>(o.entrySet()));
+    assertThat(new ArrayList<>(o.entrySet())).isEqualTo(expectedEntriesList);
 
     Iterator<Entry<String, JsonElement>> iterator = o.entrySet().iterator();
     // Test behavior of Entry.setValue
@@ -308,14 +303,14 @@ public class JsonObjectTest {
       Entry<String, JsonElement> entry = iterator.next();
       entry.setValue(new JsonPrimitive(i));
 
-      assertEquals(new JsonPrimitive(i), entry.getValue());
+      assertThat(entry.getValue()).isEqualTo(new JsonPrimitive(i));
     }
 
     expectedEntriesList = Arrays.asList(
         new SimpleEntry<>("b", new JsonPrimitive(0)),
         new SimpleEntry<>("a", new JsonPrimitive(1))
       );
-    assertEquals(expectedEntriesList, new ArrayList<>(o.entrySet()));
+    assertThat(new ArrayList<>(o.entrySet())).isEqualTo(expectedEntriesList);
 
     Entry<String, JsonElement> entry = o.entrySet().iterator().next();
     try {
@@ -325,9 +320,9 @@ public class JsonObjectTest {
       entry.setValue(null);
       fail();
     } catch (NullPointerException e) {
-      assertEquals("value == null", e.getMessage());
+      assertThat(e).hasMessageThat().isEqualTo("value == null");
     }
-    assertNotNull(entry.getValue());
+    assertThat(entry.getValue()).isNotNull();
 
     o.addProperty("key1", 1);
     o.addProperty("key2", 2);
@@ -339,18 +334,18 @@ public class JsonObjectTest {
         new SimpleEntry<>("key2", new JsonPrimitive(2))
       ));
     // Note: Must wrap in ArrayList because Deque implementations do not implement `equals`
-    assertEquals(new ArrayList<>(expectedEntriesQueue), new ArrayList<>(o.entrySet()));
+    assertThat(new ArrayList<>(o.entrySet())).isEqualTo(new ArrayList<>(expectedEntriesQueue));
     iterator = o.entrySet().iterator();
 
     // Remove entries one by one
     for (int i = o.size(); i >= 1; i--) {
-      assertTrue(iterator.hasNext());
-      assertEquals(expectedEntriesQueue.getFirst(), iterator.next());
+      assertThat(iterator.hasNext()).isTrue();
+      assertThat(iterator.next()).isEqualTo(expectedEntriesQueue.getFirst());
       iterator.remove();
       expectedEntriesQueue.removeFirst();
 
-      assertEquals(i - 1, o.size());
-      assertEquals(new ArrayList<>(expectedEntriesQueue), new ArrayList<>(o.entrySet()));
+      assertThat(o.size()).isEqualTo(i - 1);
+      assertThat(new ArrayList<>(o.entrySet())).isEqualTo(new ArrayList<>(expectedEntriesQueue));
     }
   }
 }
diff --git a/gson/src/test/java/com/google/gson/JsonParserParameterizedTest.java b/gson/src/test/java/com/google/gson/JsonParserParameterizedTest.java
index 8671fd83..936a678f 100644
--- a/gson/src/test/java/com/google/gson/JsonParserParameterizedTest.java
+++ b/gson/src/test/java/com/google/gson/JsonParserParameterizedTest.java
@@ -1,8 +1,7 @@
 package com.google.gson;
 
-import static org.junit.Assert.assertEquals;
+import static com.google.common.truth.Truth.assertThat;
 
-import java.io.IOException;
 import java.util.Arrays;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -31,11 +30,11 @@ public class JsonParserParameterizedTest {
   public String json;
 
   @Test
-  public void testParse() throws IOException {
+  public void testParse() {
     JsonElement deserialized = JsonParser.parseString(json);
     String actualSerialized = adapter.toJson(deserialized);
 
     // Serialized JsonElement should be the same as original JSON
-    assertEquals(json, actualSerialized);
+    assertThat(actualSerialized).isEqualTo(json);
   }
 }
diff --git a/gson/src/test/java/com/google/gson/JsonParserTest.java b/gson/src/test/java/com/google/gson/JsonParserTest.java
index a05aa322..587ba35d 100644
--- a/gson/src/test/java/com/google/gson/JsonParserTest.java
+++ b/gson/src/test/java/com/google/gson/JsonParserTest.java
@@ -16,23 +16,26 @@
 
 package com.google.gson;
 
-import java.io.CharArrayReader;
-import java.io.CharArrayWriter;
-import java.io.IOException;
-import java.io.StringReader;
-import junit.framework.TestCase;
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.fail;
 
 import com.google.gson.common.TestTypes.BagOfPrimitives;
 import com.google.gson.internal.Streams;
 import com.google.gson.stream.JsonReader;
+import java.io.CharArrayReader;
+import java.io.CharArrayWriter;
+import java.io.IOException;
+import java.io.StringReader;
+import org.junit.Test;
 
 /**
  * Unit test for {@link JsonParser}
  *
  * @author Inderjeet Singh
  */
-public class JsonParserTest extends TestCase {
+public class JsonParserTest {
 
+  @Test
   public void testParseInvalidJson() {
     try {
       JsonParser.parseString("[[]");
@@ -40,37 +43,43 @@ public class JsonParserTest extends TestCase {
     } catch (JsonSyntaxException expected) { }
   }
 
+  @Test
   public void testParseUnquotedStringArrayFails() {
     JsonElement element = JsonParser.parseString("[a,b,c]");
-    assertEquals("a", element.getAsJsonArray().get(0).getAsString());
-    assertEquals("b", element.getAsJsonArray().get(1).getAsString());
-    assertEquals("c", element.getAsJsonArray().get(2).getAsString());
-    assertEquals(3, element.getAsJsonArray().size());
+    assertThat(element.getAsJsonArray().get(0).getAsString()).isEqualTo("a");
+    assertThat(element.getAsJsonArray().get(1).getAsString()).isEqualTo("b");
+    assertThat(element.getAsJsonArray().get(2).getAsString()).isEqualTo("c");
+    assertThat(element.getAsJsonArray()).hasSize(3);
   }
 
+  @Test
   public void testParseString() {
     String json = "{a:10,b:'c'}";
     JsonElement e = JsonParser.parseString(json);
-    assertTrue(e.isJsonObject());
-    assertEquals(10, e.getAsJsonObject().get("a").getAsInt());
-    assertEquals("c", e.getAsJsonObject().get("b").getAsString());
+    assertThat(e.isJsonObject()).isTrue();
+    assertThat(e.getAsJsonObject().get("a").getAsInt()).isEqualTo(10);
+    assertThat(e.getAsJsonObject().get("b").getAsString()).isEqualTo("c");
   }
 
+  @Test
   public void testParseEmptyString() {
     JsonElement e = JsonParser.parseString("\"   \"");
-    assertTrue(e.isJsonPrimitive());
-    assertEquals("   ", e.getAsString());
+    assertThat(e.isJsonPrimitive()).isTrue();
+    assertThat(e.getAsString()).isEqualTo("   ");
   }
 
+  @Test
   public void testParseEmptyWhitespaceInput() {
     JsonElement e = JsonParser.parseString("     ");
-    assertTrue(e.isJsonNull());
+    assertThat(e.isJsonNull()).isTrue();
   }
 
+  @Test
   public void testParseUnquotedSingleWordStringFails() {
-    assertEquals("Test", JsonParser.parseString("Test").getAsString());
+    assertThat(JsonParser.parseString("Test").getAsString()).isEqualTo("Test");
   }
 
+  @Test
   public void testParseUnquotedMultiWordStringFails() {
     String unquotedSentence = "Test is a test..blah blah";
     try {
@@ -79,15 +88,16 @@ public class JsonParserTest extends TestCase {
     } catch (JsonSyntaxException expected) { }
   }
 
+  @Test
   public void testParseMixedArray() {
     String json = "[{},13,\"stringValue\"]";
     JsonElement e = JsonParser.parseString(json);
-    assertTrue(e.isJsonArray());
+    assertThat(e.isJsonArray()).isTrue();
 
     JsonArray  array = e.getAsJsonArray();
-    assertEquals("{}", array.get(0).toString());
-    assertEquals(13, array.get(1).getAsInt());
-    assertEquals("stringValue", array.get(2).getAsString());
+    assertThat(array.get(0).toString()).isEqualTo("{}");
+    assertThat(array.get(1).getAsInt()).isEqualTo(13);
+    assertThat(array.get(2).getAsString()).isEqualTo("stringValue");
   }
 
   private static String repeat(String s, int times) {
@@ -99,6 +109,7 @@ public class JsonParserTest extends TestCase {
   }
 
   /** Deeply nested JSON arrays should not cause {@link StackOverflowError} */
+  @Test
   public void testParseDeeplyNestedArrays() throws IOException {
     int times = 10000;
     // [[[ ... ]]]
@@ -111,13 +122,14 @@ public class JsonParserTest extends TestCase {
       if (current.isEmpty()) {
         break;
       }
-      assertEquals(1, current.size());
+      assertThat(current.size()).isEqualTo(1);
       current = current.get(0).getAsJsonArray();
     }
-    assertEquals(times, actualTimes);
+    assertThat(actualTimes).isEqualTo(times);
   }
 
   /** Deeply nested JSON objects should not cause {@link StackOverflowError} */
+  @Test
   public void testParseDeeplyNestedObjects() throws IOException {
     int times = 10000;
     // {"a":{"a": ... {"a":null} ... }}
@@ -126,7 +138,7 @@ public class JsonParserTest extends TestCase {
     int actualTimes = 0;
     JsonObject current = JsonParser.parseString(json).getAsJsonObject();
     while (true) {
-      assertEquals(1, current.size());
+      assertThat(current.size()).isEqualTo(1);
       actualTimes++;
       JsonElement next = current.get("a");
       if (next.isJsonNull()) {
@@ -135,17 +147,19 @@ public class JsonParserTest extends TestCase {
         current = next.getAsJsonObject();
       }
     }
-    assertEquals(times, actualTimes);
+    assertThat(actualTimes).isEqualTo(times);
   }
 
+  @Test
   public void testParseReader() {
     StringReader reader = new StringReader("{a:10,b:'c'}");
     JsonElement e = JsonParser.parseReader(reader);
-    assertTrue(e.isJsonObject());
-    assertEquals(10, e.getAsJsonObject().get("a").getAsInt());
-    assertEquals("c", e.getAsJsonObject().get("b").getAsString());
+    assertThat(e.isJsonObject()).isTrue();
+    assertThat(e.getAsJsonObject().get("a").getAsInt()).isEqualTo(10);
+    assertThat(e.getAsJsonObject().get("b").getAsString()).isEqualTo("c");
   }
 
+  @Test
   public void testReadWriteTwoObjects() throws Exception {
     Gson gson = new Gson();
     CharArrayWriter writer = new CharArrayWriter();
@@ -160,8 +174,8 @@ public class JsonParserTest extends TestCase {
     JsonElement element1 = Streams.parse(parser);
     JsonElement element2 = Streams.parse(parser);
     BagOfPrimitives actualOne = gson.fromJson(element1, BagOfPrimitives.class);
-    assertEquals("one", actualOne.stringValue);
+    assertThat(actualOne.stringValue).isEqualTo("one");
     BagOfPrimitives actualTwo = gson.fromJson(element2, BagOfPrimitives.class);
-    assertEquals("two", actualTwo.stringValue);
+    assertThat(actualTwo.stringValue).isEqualTo("two");
   }
 }
diff --git a/gson/src/test/java/com/google/gson/JsonPrimitiveTest.java b/gson/src/test/java/com/google/gson/JsonPrimitiveTest.java
index ae2e0f2a..b5b96638 100644
--- a/gson/src/test/java/com/google/gson/JsonPrimitiveTest.java
+++ b/gson/src/test/java/com/google/gson/JsonPrimitiveTest.java
@@ -16,19 +16,24 @@
 
 package com.google.gson;
 
+import static com.google.common.truth.Truth.assertThat;
+import static com.google.common.truth.Truth.assertWithMessage;
+import static org.junit.Assert.fail;
+
 import com.google.gson.common.MoreAsserts;
 import java.math.BigDecimal;
 import java.math.BigInteger;
-import junit.framework.TestCase;
+import org.junit.Test;
 
 /**
  * Unit test for the {@link JsonPrimitive} class.
  *
  * @author Joel Leitch
  */
-public class JsonPrimitiveTest extends TestCase {
+public class JsonPrimitiveTest {
 
   @SuppressWarnings("unused")
+  @Test
   public void testNulls() {
     try {
       new JsonPrimitive((Boolean) null);
@@ -52,91 +57,96 @@ public class JsonPrimitiveTest extends TestCase {
     }
   }
 
-  public void testBoolean() throws Exception {
+  @Test
+  public void testBoolean() {
     JsonPrimitive json = new JsonPrimitive(Boolean.TRUE);
 
-    assertTrue(json.isBoolean());
-    assertTrue(json.getAsBoolean());
+    assertThat(json.isBoolean()).isTrue();
+    assertThat(json.getAsBoolean()).isTrue();
 
     // Extra support for booleans
     json = new JsonPrimitive(1);
-    assertFalse(json.getAsBoolean());
+    assertThat(json.getAsBoolean()).isFalse();
 
     json = new JsonPrimitive("1");
-    assertFalse(json.getAsBoolean());
+    assertThat(json.getAsBoolean()).isFalse();
 
     json = new JsonPrimitive("true");
-    assertTrue(json.getAsBoolean());
+    assertThat(json.getAsBoolean()).isTrue();
 
     json = new JsonPrimitive("TrUe");
-    assertTrue(json.getAsBoolean());
+    assertThat(json.getAsBoolean()).isTrue();
 
     json = new JsonPrimitive("1.3");
-    assertFalse(json.getAsBoolean());
+    assertThat(json.getAsBoolean()).isFalse();
   }
 
-  public void testParsingStringAsBoolean() throws Exception {
+  @Test
+  public void testParsingStringAsBoolean() {
     JsonPrimitive json = new JsonPrimitive("true");
 
-    assertFalse(json.isBoolean());
-    assertTrue(json.getAsBoolean());
+    assertThat(json.isBoolean()).isFalse();
+    assertThat(json.getAsBoolean()).isTrue();
   }
 
-  public void testParsingStringAsNumber() throws Exception {
+  @Test
+  public void testParsingStringAsNumber() {
     JsonPrimitive json = new JsonPrimitive("1");
 
-    assertFalse(json.isNumber());
-    assertEquals(1D, json.getAsDouble(), 0.00001);
-    assertEquals(1F, json.getAsFloat(), 0.00001);
-    assertEquals(1, json.getAsInt());
-    assertEquals(1L, json.getAsLong());
-    assertEquals((short) 1, json.getAsShort());
-    assertEquals((byte) 1, json.getAsByte());
-    assertEquals(new BigInteger("1"), json.getAsBigInteger());
-    assertEquals(new BigDecimal("1"), json.getAsBigDecimal());
+    assertThat(json.isNumber()).isFalse();
+    assertThat(json.getAsDouble()).isEqualTo(1.0);
+    assertThat(json.getAsFloat()).isEqualTo(1F);
+    assertThat(json.getAsInt()).isEqualTo(1);
+    assertThat(json.getAsLong()).isEqualTo(1L);
+    assertThat(json.getAsShort()).isEqualTo((short) 1);
+    assertThat(json.getAsByte()).isEqualTo((byte) 1);
+    assertThat(json.getAsBigInteger()).isEqualTo(new BigInteger("1"));
+    assertThat(json.getAsBigDecimal()).isEqualTo(new BigDecimal("1"));
   }
 
+  @Test
   public void testAsNumber_Boolean() {
     JsonPrimitive json = new JsonPrimitive(true);
     try {
       json.getAsNumber();
       fail();
     } catch (UnsupportedOperationException e) {
-      assertEquals("Primitive is neither a number nor a string", e.getMessage());
+      assertThat(e).hasMessageThat().isEqualTo("Primitive is neither a number nor a string");
     }
   }
 
   @SuppressWarnings("deprecation")
-  public void testStringsAndChar() throws Exception {
+  @Test
+  public void testStringsAndChar() {
     JsonPrimitive json = new JsonPrimitive("abc");
-    assertTrue(json.isString());
-    assertEquals('a', json.getAsCharacter());
-    assertEquals("abc", json.getAsString());
+    assertThat(json.isString()).isTrue();
+    assertThat(json.getAsCharacter()).isEqualTo('a');
+    assertThat(json.getAsString()).isEqualTo("abc");
 
     json = new JsonPrimitive('z');
-    assertTrue(json.isString());
-    assertEquals('z', json.getAsCharacter());
-    assertEquals("z", json.getAsString());
+    assertThat(json.isString()).isTrue();
+    assertThat(json.getAsCharacter()).isEqualTo('z');
+    assertThat(json.getAsString()).isEqualTo("z");
 
     json = new JsonPrimitive(true);
-    assertEquals("true", json.getAsString());
+    assertThat(json.getAsString()).isEqualTo("true");
 
     json = new JsonPrimitive("");
-    assertEquals("", json.getAsString());
+    assertThat(json.getAsString()).isEqualTo("");
     try {
       json.getAsCharacter();
       fail();
     } catch (UnsupportedOperationException e) {
-      assertEquals("String value is empty", e.getMessage());
+      assertThat(e).hasMessageThat().isEqualTo("String value is empty");
     }
   }
 
-  public void testExponential() throws Exception {
+  @Test
+  public void testExponential() {
     JsonPrimitive json = new JsonPrimitive("1E+7");
 
-    assertEquals(new BigDecimal("1E+7"), json.getAsBigDecimal());
-    assertEquals(1E+7, json.getAsDouble(), 0.00001);
-    assertEquals(1E+7, json.getAsDouble(), 0.00001);
+    assertThat(json.getAsBigDecimal()).isEqualTo(new BigDecimal("1E+7"));
+    assertThat(json.getAsDouble()).isEqualTo(1E+7);
 
     try {
       json.getAsInt();
@@ -144,105 +154,120 @@ public class JsonPrimitiveTest extends TestCase {
     } catch (NumberFormatException expected) { }
   }
 
+  @Test
   public void testByteEqualsShort() {
-    JsonPrimitive p1 = new JsonPrimitive(Byte.valueOf((byte)10));
-    JsonPrimitive p2 = new JsonPrimitive(Short.valueOf((short)10));
-    assertEquals(p1, p2);
-    assertEquals(p1.hashCode(), p2.hashCode());
+    JsonPrimitive p1 = new JsonPrimitive((byte) 10);
+    JsonPrimitive p2 = new JsonPrimitive((short) 10);
+    assertThat(p1).isEqualTo(p2);
+    assertThat(p1.hashCode()).isEqualTo(p2.hashCode());
   }
 
+  @Test
   public void testByteEqualsInteger() {
-    JsonPrimitive p1 = new JsonPrimitive(Byte.valueOf((byte)10));
-    JsonPrimitive p2 = new JsonPrimitive(Integer.valueOf(10));
-    assertEquals(p1, p2);
-    assertEquals(p1.hashCode(), p2.hashCode());
+    JsonPrimitive p1 = new JsonPrimitive((byte) 10);
+    JsonPrimitive p2 = new JsonPrimitive(10);
+    assertThat(p1).isEqualTo(p2);
+    assertThat(p1.hashCode()).isEqualTo(p2.hashCode());
   }
 
+  @Test
   public void testByteEqualsLong() {
-    JsonPrimitive p1 = new JsonPrimitive(Byte.valueOf((byte)10));
-    JsonPrimitive p2 = new JsonPrimitive(Long.valueOf(10L));
-    assertEquals(p1, p2);
-    assertEquals(p1.hashCode(), p2.hashCode());
+    JsonPrimitive p1 = new JsonPrimitive((byte) 10);
+    JsonPrimitive p2 = new JsonPrimitive(10L);
+    assertThat(p1).isEqualTo(p2);
+    assertThat(p1.hashCode()).isEqualTo(p2.hashCode());
   }
 
+  @Test
   public void testByteEqualsBigInteger() {
-    JsonPrimitive p1 = new JsonPrimitive(Byte.valueOf((byte)10));
+    JsonPrimitive p1 = new JsonPrimitive((byte) 10);
     JsonPrimitive p2 = new JsonPrimitive(new BigInteger("10"));
-    assertEquals(p1, p2);
-    assertEquals(p1.hashCode(), p2.hashCode());
+    assertThat(p1).isEqualTo(p2);
+    assertThat(p1.hashCode()).isEqualTo(p2.hashCode());
   }
 
+  @Test
   public void testShortEqualsInteger() {
-    JsonPrimitive p1 = new JsonPrimitive(Short.valueOf((short)10));
-    JsonPrimitive p2 = new JsonPrimitive(Integer.valueOf(10));
-    assertEquals(p1, p2);
-    assertEquals(p1.hashCode(), p2.hashCode());
+    JsonPrimitive p1 = new JsonPrimitive((short) 10);
+    JsonPrimitive p2 = new JsonPrimitive(10);
+    assertThat(p1).isEqualTo(p2);
+    assertThat(p1.hashCode()).isEqualTo(p2.hashCode());
   }
 
+  @Test
   public void testShortEqualsLong() {
-    JsonPrimitive p1 = new JsonPrimitive(Short.valueOf((short)10));
-    JsonPrimitive p2 = new JsonPrimitive(Long.valueOf(10));
-    assertEquals(p1, p2);
-    assertEquals(p1.hashCode(), p2.hashCode());
+    JsonPrimitive p1 = new JsonPrimitive((short) 10);
+    JsonPrimitive p2 = new JsonPrimitive(10L);
+    assertThat(p1).isEqualTo(p2);
+    assertThat(p1.hashCode()).isEqualTo(p2.hashCode());
   }
 
+  @Test
   public void testShortEqualsBigInteger() {
-    JsonPrimitive p1 = new JsonPrimitive(Short.valueOf((short)10));
+    JsonPrimitive p1 = new JsonPrimitive((short) 10);
     JsonPrimitive p2 = new JsonPrimitive(new BigInteger("10"));
-    assertEquals(p1, p2);
-    assertEquals(p1.hashCode(), p2.hashCode());
+    assertThat(p1).isEqualTo(p2);
+    assertThat(p1.hashCode()).isEqualTo(p2.hashCode());
   }
 
+  @Test
   public void testIntegerEqualsLong() {
-    JsonPrimitive p1 = new JsonPrimitive(Integer.valueOf(10));
-    JsonPrimitive p2 = new JsonPrimitive(Long.valueOf(10L));
-    assertEquals(p1, p2);
-    assertEquals(p1.hashCode(), p2.hashCode());
+    JsonPrimitive p1 = new JsonPrimitive(10);
+    JsonPrimitive p2 = new JsonPrimitive(10L);
+    assertThat(p1).isEqualTo(p2);
+    assertThat(p1.hashCode()).isEqualTo(p2.hashCode());
   }
 
+  @Test
   public void testIntegerEqualsBigInteger() {
-    JsonPrimitive p1 = new JsonPrimitive(Integer.valueOf(10));
+    JsonPrimitive p1 = new JsonPrimitive(10);
     JsonPrimitive p2 = new JsonPrimitive(new BigInteger("10"));
-    assertEquals(p1, p2);
-    assertEquals(p1.hashCode(), p2.hashCode());
+    assertThat(p1).isEqualTo(p2);
+    assertThat(p1.hashCode()).isEqualTo(p2.hashCode());
   }
 
+  @Test
   public void testLongEqualsBigInteger() {
-    JsonPrimitive p1 = new JsonPrimitive(Long.valueOf(10L));
+    JsonPrimitive p1 = new JsonPrimitive(10L);
     JsonPrimitive p2 = new JsonPrimitive(new BigInteger("10"));
-    assertEquals(p1, p2);
-    assertEquals(p1.hashCode(), p2.hashCode());
+    assertThat(p1).isEqualTo(p2);
+    assertThat(p1.hashCode()).isEqualTo(p2.hashCode());
   }
 
+  @Test
   public void testFloatEqualsDouble() {
-    JsonPrimitive p1 = new JsonPrimitive(Float.valueOf(10.25F));
-    JsonPrimitive p2 = new JsonPrimitive(Double.valueOf(10.25D));
-    assertEquals(p1, p2);
-    assertEquals(p1.hashCode(), p2.hashCode());
+    JsonPrimitive p1 = new JsonPrimitive(10.25F);
+    JsonPrimitive p2 = new JsonPrimitive(10.25D);
+    assertThat(p1).isEqualTo(p2);
+    assertThat(p1.hashCode()).isEqualTo(p2.hashCode());
   }
 
+  @Test
   public void testFloatEqualsBigDecimal() {
-    JsonPrimitive p1 = new JsonPrimitive(Float.valueOf(10.25F));
+    JsonPrimitive p1 = new JsonPrimitive(10.25F);
     JsonPrimitive p2 = new JsonPrimitive(new BigDecimal("10.25"));
-    assertEquals(p1, p2);
-    assertEquals(p1.hashCode(), p2.hashCode());
+    assertThat(p1).isEqualTo(p2);
+    assertThat(p1.hashCode()).isEqualTo(p2.hashCode());
   }
 
+  @Test
   public void testDoubleEqualsBigDecimal() {
-    JsonPrimitive p1 = new JsonPrimitive(Double.valueOf(10.25D));
+    JsonPrimitive p1 = new JsonPrimitive(10.25D);
     JsonPrimitive p2 = new JsonPrimitive(new BigDecimal("10.25"));
-    assertEquals(p1, p2);
-    assertEquals(p1.hashCode(), p2.hashCode());
+    assertThat(p1).isEqualTo(p2);
+    assertThat(p1.hashCode()).isEqualTo(p2.hashCode());
   }
 
-  public void testValidJsonOnToString() throws Exception {
+  @Test
+  public void testValidJsonOnToString() {
     JsonPrimitive json = new JsonPrimitive("Some\nEscaped\nValue");
-    assertEquals("\"Some\\nEscaped\\nValue\"", json.toString());
+    assertThat(json.toString()).isEqualTo("\"Some\\nEscaped\\nValue\"");
 
     json = new JsonPrimitive(new BigDecimal("1.333"));
-    assertEquals("1.333", json.toString());
+    assertThat(json.toString()).isEqualTo("1.333");
   }
 
+  @Test
   public void testEquals() {
     MoreAsserts.assertEqualsAndHashCode(new JsonPrimitive("A"), new JsonPrimitive("A"));
     MoreAsserts.assertEqualsAndHashCode(new JsonPrimitive(true), new JsonPrimitive(true));
@@ -258,11 +283,12 @@ public class JsonPrimitiveTest extends TestCase {
         new JsonPrimitive(Double.NEGATIVE_INFINITY));
     MoreAsserts.assertEqualsAndHashCode(new JsonPrimitive(Double.POSITIVE_INFINITY),
         new JsonPrimitive(Double.POSITIVE_INFINITY));
-    assertFalse(new JsonPrimitive("a").equals(new JsonPrimitive("b")));
-    assertFalse(new JsonPrimitive(true).equals(new JsonPrimitive(false)));
-    assertFalse(new JsonPrimitive(0).equals(new JsonPrimitive(1)));
+    assertThat(new JsonPrimitive("a").equals(new JsonPrimitive("b"))).isFalse();
+    assertThat(new JsonPrimitive(true).equals(new JsonPrimitive(false))).isFalse();
+    assertThat(new JsonPrimitive(0).equals(new JsonPrimitive(1))).isFalse();
   }
 
+  @Test
   public void testEqualsAcrossTypes() {
     MoreAsserts.assertEqualsAndHashCode(new JsonPrimitive("a"), new JsonPrimitive('a'));
     MoreAsserts.assertEqualsAndHashCode(new JsonPrimitive(new BigInteger("0")), new JsonPrimitive(0));
@@ -271,22 +297,25 @@ public class JsonPrimitiveTest extends TestCase {
     MoreAsserts.assertEqualsAndHashCode(new JsonPrimitive(Float.NaN), new JsonPrimitive(Double.NaN));
   }
 
+  @Test
   public void testEqualsIntegerAndBigInteger() {
     JsonPrimitive a = new JsonPrimitive(5L);
     JsonPrimitive b = new JsonPrimitive(new BigInteger("18446744073709551621")); // 2^64 + 5
     // Ideally, the following assertion should have failed but the price is too much to pay
     // assertFalse(a + " equals " + b, a.equals(b));
-    assertTrue(a + " equals " + b, a.equals(b));
+    assertWithMessage("%s equals %s", a, b).that(a.equals(b)).isTrue();
   }
 
+  @Test
   public void testEqualsDoesNotEquateStringAndNonStringTypes() {
-    assertFalse(new JsonPrimitive("true").equals(new JsonPrimitive(true)));
-    assertFalse(new JsonPrimitive("0").equals(new JsonPrimitive(0)));
-    assertFalse(new JsonPrimitive("NaN").equals(new JsonPrimitive(Float.NaN)));
+    assertThat(new JsonPrimitive("true").equals(new JsonPrimitive(true))).isFalse();
+    assertThat(new JsonPrimitive("0").equals(new JsonPrimitive(0))).isFalse();
+    assertThat(new JsonPrimitive("NaN").equals(new JsonPrimitive(Float.NaN))).isFalse();
   }
 
+  @Test
   public void testDeepCopy() {
     JsonPrimitive a = new JsonPrimitive("a");
-    assertSame(a, a.deepCopy()); // Primitives are immutable!
+    assertThat(a).isSameInstanceAs(a.deepCopy()); // Primitives are immutable!
   }
 }
diff --git a/gson/src/test/java/com/google/gson/JsonStreamParserTest.java b/gson/src/test/java/com/google/gson/JsonStreamParserTest.java
index 1b40b58b..7d577787 100644
--- a/gson/src/test/java/com/google/gson/JsonStreamParserTest.java
+++ b/gson/src/test/java/com/google/gson/JsonStreamParserTest.java
@@ -15,53 +15,60 @@
  */
 package com.google.gson;
 
-import junit.framework.TestCase;
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.fail;
 
+import java.io.EOFException;
 import java.util.NoSuchElementException;
+import org.junit.Before;
+import org.junit.Test;
 
 /**
  * Unit tests for {@link JsonStreamParser}
- * 
+ *
  * @author Inderjeet Singh
  */
-public class JsonStreamParserTest extends TestCase {
+public class JsonStreamParserTest {
   private JsonStreamParser parser;
-  
-  @Override
-  protected void setUp() throws Exception {
-    super.setUp();
+
+  @Before
+  public void setUp() throws Exception {
     parser = new JsonStreamParser("'one' 'two'");
   }
 
+  @Test
   public void testParseTwoStrings() {
     String actualOne = parser.next().getAsString();
-    assertEquals("one", actualOne);
+    assertThat(actualOne).isEqualTo("one");
     String actualTwo = parser.next().getAsString();
-    assertEquals("two", actualTwo);
+    assertThat(actualTwo).isEqualTo("two");
   }
 
+  @Test
   public void testIterator() {
-    assertTrue(parser.hasNext());
-    assertEquals("one", parser.next().getAsString());
-    assertTrue(parser.hasNext());
-    assertEquals("two", parser.next().getAsString());
-    assertFalse(parser.hasNext());
+    assertThat(parser.hasNext()).isTrue();
+    assertThat(parser.next().getAsString()).isEqualTo("one");
+    assertThat(parser.hasNext()).isTrue();
+    assertThat(parser.next().getAsString()).isEqualTo("two");
+    assertThat(parser.hasNext()).isFalse();
   }
 
-  public void testNoSideEffectForHasNext() throws Exception {
-    assertTrue(parser.hasNext());
-    assertTrue(parser.hasNext());
-    assertTrue(parser.hasNext());
-    assertEquals("one", parser.next().getAsString());
-    
-    assertTrue(parser.hasNext());
-    assertTrue(parser.hasNext());
-    assertEquals("two", parser.next().getAsString());
-    
-    assertFalse(parser.hasNext());
-    assertFalse(parser.hasNext());
+  @Test
+  public void testNoSideEffectForHasNext() {
+    assertThat(parser.hasNext()).isTrue();
+    assertThat(parser.hasNext()).isTrue();
+    assertThat(parser.hasNext()).isTrue();
+    assertThat(parser.next().getAsString()).isEqualTo("one");
+
+    assertThat(parser.hasNext()).isTrue();
+    assertThat(parser.hasNext()).isTrue();
+    assertThat(parser.next().getAsString()).isEqualTo("two");
+
+    assertThat(parser.hasNext()).isFalse();
+    assertThat(parser.hasNext()).isFalse();
   }
 
+  @Test
   public void testCallingNextBeyondAvailableInput() {
     parser.next();
     parser.next();
@@ -71,4 +78,51 @@ public class JsonStreamParserTest extends TestCase {
     } catch (NoSuchElementException expected) {
     }
   }
+
+  @Test
+  public void testEmptyInput() {
+    JsonStreamParser parser = new JsonStreamParser("");
+    try {
+      parser.next();
+      fail();
+    } catch (JsonIOException e) {
+      assertThat(e.getCause()).isInstanceOf(EOFException.class);
+    }
+
+    parser = new JsonStreamParser("");
+    try {
+      parser.hasNext();
+      fail();
+    } catch (JsonIOException e) {
+      assertThat(e.getCause()).isInstanceOf(EOFException.class);
+    }
+  }
+
+  @Test
+  public void testIncompleteInput() {
+    JsonStreamParser parser = new JsonStreamParser("[");
+    assertThat(parser.hasNext()).isTrue();
+    try {
+      parser.next();
+      fail();
+    } catch (JsonSyntaxException e) {
+    }
+  }
+
+  @Test
+  public void testMalformedInput() {
+    JsonStreamParser parser = new JsonStreamParser(":");
+    try {
+      parser.hasNext();
+      fail();
+    } catch (JsonSyntaxException e) {
+    }
+
+    parser = new JsonStreamParser(":");
+    try {
+      parser.next();
+      fail();
+    } catch (JsonSyntaxException e) {
+    }
+  }
 }
diff --git a/gson/src/test/java/com/google/gson/LongSerializationPolicyTest.java b/gson/src/test/java/com/google/gson/LongSerializationPolicyTest.java
index a4ad8f14..cb36f943 100644
--- a/gson/src/test/java/com/google/gson/LongSerializationPolicyTest.java
+++ b/gson/src/test/java/com/google/gson/LongSerializationPolicyTest.java
@@ -16,7 +16,9 @@
 
 package com.google.gson;
 
-import junit.framework.TestCase;
+import static com.google.common.truth.Truth.assertThat;
+
+import org.junit.Test;
 
 /**
  * Unit test for the {@link LongSerializationPolicy} class.
@@ -24,61 +26,67 @@ import junit.framework.TestCase;
  * @author Inderjeet Singh
  * @author Joel Leitch
  */
-public class LongSerializationPolicyTest extends TestCase {
+public class LongSerializationPolicyTest {
 
+  @Test
   public void testDefaultLongSerialization() throws Exception {
     JsonElement element = LongSerializationPolicy.DEFAULT.serialize(1556L);
-    assertTrue(element.isJsonPrimitive());
+    assertThat(element.isJsonPrimitive()).isTrue();
 
     JsonPrimitive jsonPrimitive = element.getAsJsonPrimitive();
-    assertFalse(jsonPrimitive.isString());
-    assertTrue(jsonPrimitive.isNumber());
-    assertEquals(1556L, element.getAsLong());
+    assertThat(jsonPrimitive.isString()).isFalse();
+    assertThat(jsonPrimitive.isNumber()).isTrue();
+    assertThat(element.getAsLong()).isEqualTo(1556L);
   }
 
+  @Test
   public void testDefaultLongSerializationIntegration() {
     Gson gson = new GsonBuilder()
       .setLongSerializationPolicy(LongSerializationPolicy.DEFAULT)
       .create();
-    assertEquals("[1]", gson.toJson(new long[] { 1L }, long[].class));
-    assertEquals("[1]", gson.toJson(new Long[] { 1L }, Long[].class));
+    assertThat(gson.toJson(new long[] { 1L }, long[].class)).isEqualTo("[1]");
+    assertThat(gson.toJson(new Long[] { 1L }, Long[].class)).isEqualTo("[1]");
   }
 
+  @Test
   public void testDefaultLongSerializationNull() {
     LongSerializationPolicy policy = LongSerializationPolicy.DEFAULT;
-    assertTrue(policy.serialize(null).isJsonNull());
+    assertThat(policy.serialize(null).isJsonNull()).isTrue();
 
     Gson gson = new GsonBuilder()
       .setLongSerializationPolicy(policy)
       .create();
-    assertEquals("null", gson.toJson(null, Long.class));
+    assertThat(gson.toJson(null, Long.class)).isEqualTo("null");
   }
 
+  @Test
   public void testStringLongSerialization() throws Exception {
     JsonElement element = LongSerializationPolicy.STRING.serialize(1556L);
-    assertTrue(element.isJsonPrimitive());
+    assertThat(element.isJsonPrimitive()).isTrue();
 
     JsonPrimitive jsonPrimitive = element.getAsJsonPrimitive();
-    assertFalse(jsonPrimitive.isNumber());
-    assertTrue(jsonPrimitive.isString());
-    assertEquals("1556", element.getAsString());
+    assertThat(jsonPrimitive.isNumber()).isFalse();
+    assertThat(jsonPrimitive.isString()).isTrue();
+    assertThat(element.getAsString()).isEqualTo("1556");
   }
 
+  @Test
   public void testStringLongSerializationIntegration() {
     Gson gson = new GsonBuilder()
       .setLongSerializationPolicy(LongSerializationPolicy.STRING)
       .create();
-    assertEquals("[\"1\"]", gson.toJson(new long[] { 1L }, long[].class));
-    assertEquals("[\"1\"]", gson.toJson(new Long[] { 1L }, Long[].class));
+    assertThat(gson.toJson(new long[] { 1L }, long[].class)).isEqualTo("[\"1\"]");
+    assertThat(gson.toJson(new Long[] { 1L }, long[].class)).isEqualTo("[\"1\"]");
   }
 
+  @Test
   public void testStringLongSerializationNull() {
     LongSerializationPolicy policy = LongSerializationPolicy.STRING;
-    assertTrue(policy.serialize(null).isJsonNull());
+    assertThat(policy.serialize(null).isJsonNull()).isTrue();
 
     Gson gson = new GsonBuilder()
       .setLongSerializationPolicy(policy)
       .create();
-    assertEquals("null", gson.toJson(null, Long.class));
+    assertThat(gson.toJson(null, Long.class)).isEqualTo("null");
   }
 }
diff --git a/gson/src/test/java/com/google/gson/MixedStreamTest.java b/gson/src/test/java/com/google/gson/MixedStreamTest.java
index 23ed6fa9..345f234c 100644
--- a/gson/src/test/java/com/google/gson/MixedStreamTest.java
+++ b/gson/src/test/java/com/google/gson/MixedStreamTest.java
@@ -16,6 +16,9 @@
 
 package com.google.gson;
 
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.fail;
+
 import com.google.gson.reflect.TypeToken;
 import com.google.gson.stream.JsonReader;
 import com.google.gson.stream.JsonWriter;
@@ -25,9 +28,9 @@ import java.io.StringWriter;
 import java.lang.reflect.Type;
 import java.util.Arrays;
 import java.util.List;
-import junit.framework.TestCase;
+import org.junit.Test;
 
-public final class MixedStreamTest extends TestCase {
+public final class MixedStreamTest {
 
   private static final Car BLUE_MUSTANG = new Car("mustang", 0x0000FF);
   private static final Car BLACK_BMW = new Car("bmw", 0x000000);
@@ -47,6 +50,7 @@ public final class MixedStreamTest extends TestCase {
       + "  }\n"
       + "]";
 
+  @Test
   public void testWriteMixedStreamed() throws IOException {
     Gson gson = new Gson();
     StringWriter stringWriter = new StringWriter();
@@ -59,21 +63,25 @@ public final class MixedStreamTest extends TestCase {
     gson.toJson(RED_MIATA, Car.class, jsonWriter);
     jsonWriter.endArray();
 
-    assertEquals(CARS_JSON, stringWriter.toString());
+    assertThat(stringWriter.toString()).isEqualTo(CARS_JSON);
   }
 
+  @Test
   public void testReadMixedStreamed() throws IOException {
     Gson gson = new Gson();
     StringReader stringReader = new StringReader(CARS_JSON);
     JsonReader jsonReader = new JsonReader(stringReader);
 
     jsonReader.beginArray();
-    assertEquals(BLUE_MUSTANG, gson.fromJson(jsonReader, Car.class));
-    assertEquals(BLACK_BMW, gson.fromJson(jsonReader, Car.class));
-    assertEquals(RED_MIATA, gson.fromJson(jsonReader, Car.class));
+    // actual and expected object are inverted in the test.
+    // gson.fromJson(jsonReader, Car.class) as arg of assertThat() cause an ambiguous method call
+    assertThat(BLUE_MUSTANG).isEqualTo(gson.fromJson(jsonReader, Car.class));
+    assertThat(BLACK_BMW).isEqualTo(gson.fromJson(jsonReader, Car.class));
+    assertThat(RED_MIATA).isEqualTo(gson.fromJson(jsonReader, Car.class));
     jsonReader.endArray();
   }
 
+  @Test
   public void testReaderDoesNotMutateState() throws IOException {
     Gson gson = new Gson();
     JsonReader jsonReader = new JsonReader(new StringReader(CARS_JSON));
@@ -81,13 +89,14 @@ public final class MixedStreamTest extends TestCase {
 
     jsonReader.setLenient(false);
     gson.fromJson(jsonReader, Car.class);
-    assertFalse(jsonReader.isLenient());
+    assertThat(jsonReader.isLenient()).isFalse();
 
     jsonReader.setLenient(true);
     gson.fromJson(jsonReader, Car.class);
-    assertTrue(jsonReader.isLenient());
+    assertThat(jsonReader.isLenient()).isTrue();
   }
 
+  @Test
   public void testWriteDoesNotMutateState() throws IOException {
     Gson gson = new Gson();
     JsonWriter jsonWriter = new JsonWriter(new StringWriter());
@@ -96,16 +105,17 @@ public final class MixedStreamTest extends TestCase {
     jsonWriter.setHtmlSafe(true);
     jsonWriter.setLenient(true);
     gson.toJson(BLUE_MUSTANG, Car.class, jsonWriter);
-    assertTrue(jsonWriter.isHtmlSafe());
-    assertTrue(jsonWriter.isLenient());
+    assertThat(jsonWriter.isHtmlSafe()).isTrue();
+    assertThat(jsonWriter.isLenient()).isTrue();
 
     jsonWriter.setHtmlSafe(false);
     jsonWriter.setLenient(false);
     gson.toJson(BLUE_MUSTANG, Car.class, jsonWriter);
-    assertFalse(jsonWriter.isHtmlSafe());
-    assertFalse(jsonWriter.isLenient());
+    assertThat(jsonWriter.isHtmlSafe()).isFalse();
+    assertThat(jsonWriter.isLenient()).isFalse();
   }
 
+  @Test
   public void testReadInvalidState() throws IOException {
     Gson gson = new Gson();
     JsonReader jsonReader = new JsonReader(new StringReader(CARS_JSON));
@@ -118,6 +128,7 @@ public final class MixedStreamTest extends TestCase {
     }
   }
 
+  @Test
   public void testReadClosed() throws IOException {
     Gson gson = new Gson();
     JsonReader jsonReader = new JsonReader(new StringReader(CARS_JSON));
@@ -129,6 +140,7 @@ public final class MixedStreamTest extends TestCase {
     }
   }
 
+  @Test
   public void testWriteInvalidState() throws IOException {
     Gson gson = new Gson();
     JsonWriter jsonWriter = new JsonWriter(new StringWriter());
@@ -140,6 +152,7 @@ public final class MixedStreamTest extends TestCase {
     }
   }
 
+  @Test
   public void testWriteClosed() throws IOException {
     Gson gson = new Gson();
     JsonWriter jsonWriter = new JsonWriter(new StringWriter());
@@ -153,6 +166,7 @@ public final class MixedStreamTest extends TestCase {
     }
   }
 
+  @Test
   public void testWriteNulls() {
     Gson gson = new Gson();
     try {
@@ -163,9 +177,10 @@ public final class MixedStreamTest extends TestCase {
 
     StringWriter stringWriter = new StringWriter();
     gson.toJson(null, new JsonWriter(stringWriter));
-    assertEquals("null", stringWriter.toString());
+    assertThat(stringWriter.toString()).isEqualTo("null");
   }
 
+  @Test
   public void testReadNulls() {
     Gson gson = new Gson();
     try {
@@ -180,22 +195,24 @@ public final class MixedStreamTest extends TestCase {
     }
   }
 
+  @Test
   public void testWriteHtmlSafe() {
     List<String> contents = Arrays.asList("<", ">", "&", "=", "'");
     Type type = new TypeToken<List<String>>() {}.getType();
 
     StringWriter writer = new StringWriter();
     new Gson().toJson(contents, type, new JsonWriter(writer));
-    assertEquals("[\"\\u003c\",\"\\u003e\",\"\\u0026\",\"\\u003d\",\"\\u0027\"]",
-        writer.toString());
+    assertThat(writer.toString())
+        .isEqualTo("[\"\\u003c\",\"\\u003e\",\"\\u0026\",\"\\u003d\",\"\\u0027\"]");
 
     writer = new StringWriter();
     new GsonBuilder().disableHtmlEscaping().create()
         .toJson(contents, type, new JsonWriter(writer));
-    assertEquals("[\"<\",\">\",\"&\",\"=\",\"'\"]",
-        writer.toString());
+    assertThat(writer.toString())
+        .isEqualTo("[\"<\",\">\",\"&\",\"=\",\"'\"]");
   }
 
+  @Test
   public void testWriteLenient() {
     List<Double> doubles = Arrays.asList(Double.NaN, Double.NEGATIVE_INFINITY,
         Double.POSITIVE_INFINITY, -0.0d, 0.5d, 0.0d);
@@ -205,7 +222,7 @@ public final class MixedStreamTest extends TestCase {
     JsonWriter jsonWriter = new JsonWriter(writer);
     new GsonBuilder().setLenient().serializeSpecialFloatingPointValues().create()
         .toJson(doubles, type, jsonWriter);
-    assertEquals("[NaN,-Infinity,Infinity,-0.0,0.5,0.0]", writer.toString());
+    assertThat(writer.toString()).isEqualTo("[NaN,-Infinity,Infinity,-0.0,0.5,0.0]");
 
     try {
       new Gson().toJson(doubles, type, new JsonWriter(new StringWriter()));
diff --git a/gson/src/test/java/com/google/gson/ObjectTypeAdapterParameterizedTest.java b/gson/src/test/java/com/google/gson/ObjectTypeAdapterParameterizedTest.java
index 60740ce0..fe2aa9f9 100644
--- a/gson/src/test/java/com/google/gson/ObjectTypeAdapterParameterizedTest.java
+++ b/gson/src/test/java/com/google/gson/ObjectTypeAdapterParameterizedTest.java
@@ -1,6 +1,6 @@
 package com.google.gson;
 
-import static org.junit.Assert.assertEquals;
+import static com.google.common.truth.Truth.assertThat;
 
 import java.io.IOException;
 import java.util.Arrays;
@@ -36,6 +36,6 @@ public class ObjectTypeAdapterParameterizedTest {
     String actualSerialized = adapter.toJson(deserialized);
 
     // Serialized Object should be the same as original JSON
-    assertEquals(json, actualSerialized);
+    assertThat(actualSerialized).isEqualTo(json);
   }
 }
diff --git a/gson/src/test/java/com/google/gson/ObjectTypeAdapterTest.java b/gson/src/test/java/com/google/gson/ObjectTypeAdapterTest.java
index 534c398d..cdfdb013 100644
--- a/gson/src/test/java/com/google/gson/ObjectTypeAdapterTest.java
+++ b/gson/src/test/java/com/google/gson/ObjectTypeAdapterTest.java
@@ -16,45 +16,52 @@
 
 package com.google.gson;
 
+import static com.google.common.truth.Truth.assertThat;
+
 import java.io.IOException;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
-import junit.framework.TestCase;
+import org.junit.Test;
 
-public final class ObjectTypeAdapterTest extends TestCase {
+public final class ObjectTypeAdapterTest {
   private final Gson gson = new GsonBuilder().create();
   private final TypeAdapter<Object> adapter = gson.getAdapter(Object.class);
 
+  @Test
   public void testDeserialize() throws Exception {
     Map<?, ?> map = (Map<?, ?>) adapter.fromJson("{\"a\":5,\"b\":[1,2,null],\"c\":{\"x\":\"y\"}}");
-    assertEquals(5.0, map.get("a"));
-    assertEquals(Arrays.asList(1.0, 2.0, null), map.get("b"));
-    assertEquals(Collections.singletonMap("x", "y"), map.get("c"));
-    assertEquals(3, map.size());
+    assertThat(map.get("a")).isEqualTo(5.0);
+    assertThat(map.get("b")).isEqualTo(Arrays.asList(1.0, 2.0, null));
+    assertThat(map.get("c")).isEqualTo(Collections.singletonMap("x", "y"));
+    assertThat(map).hasSize(3);
   }
 
-  public void testSerialize() throws Exception {
+  @Test
+  public void testSerialize() {
     Object object = new RuntimeType();
-    assertEquals("{'a':5,'b':[1,2,null]}", adapter.toJson(object).replace("\"", "'"));
+    assertThat(adapter.toJson(object).replace("\"", "'")).isEqualTo("{'a':5,'b':[1,2,null]}");
   }
 
-  public void testSerializeNullValue() throws Exception {
+  @Test
+  public void testSerializeNullValue() {
     Map<String, Object> map = new LinkedHashMap<>();
     map.put("a", null);
-    assertEquals("{'a':null}", adapter.toJson(map).replace('"', '\''));
+    assertThat(adapter.toJson(map).replace('"', '\'')).isEqualTo("{'a':null}");
   }
 
+  @Test
   public void testDeserializeNullValue() throws Exception {
     Map<String, Object> map = new LinkedHashMap<>();
     map.put("a", null);
-    assertEquals(map, adapter.fromJson("{\"a\":null}"));
+    assertThat(adapter.fromJson("{\"a\":null}")).isEqualTo(map);
   }
 
-  public void testSerializeObject() throws Exception {
-    assertEquals("{}", adapter.toJson(new Object()));
+  @Test
+  public void testSerializeObject() {
+    assertThat(adapter.toJson(new Object())).isEqualTo("{}");
   }
 
   private static String repeat(String s, int times) {
@@ -67,6 +74,7 @@ public final class ObjectTypeAdapterTest extends TestCase {
 
   /** Deeply nested JSON arrays should not cause {@link StackOverflowError} */
   @SuppressWarnings("unchecked")
+  @Test
   public void testDeserializeDeeplyNestedArrays() throws IOException {
     int times = 10000;
     // [[[ ... ]]]
@@ -79,14 +87,15 @@ public final class ObjectTypeAdapterTest extends TestCase {
       if (current.isEmpty()) {
         break;
       }
-      assertEquals(1, current.size());
+      assertThat(current).hasSize(1);
       current = (List<List<?>>) current.get(0);
     }
-    assertEquals(times, actualTimes);
+    assertThat(actualTimes).isEqualTo(times);
   }
 
   /** Deeply nested JSON objects should not cause {@link StackOverflowError} */
   @SuppressWarnings("unchecked")
+  @Test
   public void testDeserializeDeeplyNestedObjects() throws IOException {
     int times = 10000;
     // {"a":{"a": ... {"a":null} ... }}
@@ -95,11 +104,11 @@ public final class ObjectTypeAdapterTest extends TestCase {
     int actualTimes = 0;
     Map<String, Map<?, ?>> current = (Map<String, Map<?, ?>>) adapter.fromJson(json);
     while (current != null) {
-      assertEquals(1, current.size());
+      assertThat(current).hasSize(1);
       actualTimes++;
       current = (Map<String, Map<?, ?>>) current.get("a");
     }
-    assertEquals(times, actualTimes);
+    assertThat(actualTimes).isEqualTo(times);
   }
 
   @SuppressWarnings("unused")
diff --git a/gson/src/test/java/com/google/gson/OverrideCoreTypeAdaptersTest.java b/gson/src/test/java/com/google/gson/OverrideCoreTypeAdaptersTest.java
index 79ae1698..fab0d96b 100644
--- a/gson/src/test/java/com/google/gson/OverrideCoreTypeAdaptersTest.java
+++ b/gson/src/test/java/com/google/gson/OverrideCoreTypeAdaptersTest.java
@@ -16,16 +16,18 @@
 
 package com.google.gson;
 
+import static com.google.common.truth.Truth.assertThat;
+
 import com.google.gson.stream.JsonReader;
 import com.google.gson.stream.JsonWriter;
 import java.io.IOException;
 import java.util.Locale;
-import junit.framework.TestCase;
+import org.junit.Test;
 
 /**
  * @author Jesse Wilson
  */
-public class OverrideCoreTypeAdaptersTest extends TestCase {
+public class OverrideCoreTypeAdaptersTest {
   private static final TypeAdapter<Boolean> booleanAsIntAdapter = new TypeAdapter<Boolean>() {
     @Override public void write(JsonWriter out, Boolean value) throws IOException {
       out.value(value ? 1 : 0);
@@ -45,33 +47,36 @@ public class OverrideCoreTypeAdaptersTest extends TestCase {
     }
   };
 
+  @Test
   public void testOverrideWrapperBooleanAdapter() {
     Gson gson = new GsonBuilder()
         .registerTypeAdapter(Boolean.class, booleanAsIntAdapter)
         .create();
-    assertEquals("true", gson.toJson(true, boolean.class));
-    assertEquals("1", gson.toJson(true, Boolean.class));
-    assertEquals(Boolean.TRUE, gson.fromJson("true", boolean.class));
-    assertEquals(Boolean.TRUE, gson.fromJson("1", Boolean.class));
-    assertEquals(Boolean.FALSE, gson.fromJson("0", Boolean.class));
+    assertThat(gson.toJson(true, boolean.class)).isEqualTo("true");
+    assertThat(gson.toJson(true, Boolean.class)).isEqualTo("1");
+    assertThat(gson.fromJson("true", boolean.class)).isEqualTo(Boolean.TRUE);
+    assertThat(gson.fromJson("1", Boolean.class)).isEqualTo(Boolean.TRUE);
+    assertThat(gson.fromJson("0", Boolean.class)).isEqualTo(Boolean.FALSE);
   }
 
+  @Test
   public void testOverridePrimitiveBooleanAdapter() {
     Gson gson = new GsonBuilder()
         .registerTypeAdapter(boolean.class, booleanAsIntAdapter)
         .create();
-    assertEquals("1", gson.toJson(true, boolean.class));
-    assertEquals("true", gson.toJson(true, Boolean.class));
-    assertEquals(Boolean.TRUE, gson.fromJson("1", boolean.class));
-    assertEquals(Boolean.TRUE, gson.fromJson("true", Boolean.class));
-    assertEquals("0", gson.toJson(false, boolean.class));
+    assertThat(gson.toJson(true, boolean.class)).isEqualTo("1");
+    assertThat(gson.toJson(true, Boolean.class)).isEqualTo("true");
+    assertThat(gson.fromJson("1", boolean.class)).isEqualTo(Boolean.TRUE);
+    assertThat(gson.fromJson("true", Boolean.class)).isEqualTo(Boolean.TRUE);
+    assertThat(gson.toJson(false, boolean.class)).isEqualTo("0");
   }
 
+  @Test
   public void testOverrideStringAdapter() {
     Gson gson = new GsonBuilder()
         .registerTypeAdapter(String.class, swapCaseStringAdapter)
         .create();
-    assertEquals("\"HELLO\"", gson.toJson("Hello", String.class));
-    assertEquals("hello", gson.fromJson("\"Hello\"", String.class));
+    assertThat(gson.toJson("Hello", String.class)).isEqualTo("\"HELLO\"");
+    assertThat(gson.fromJson("\"Hello\"", String.class)).isEqualTo("hello");
   }
 }
diff --git a/gson/src/test/java/com/google/gson/ParameterizedTypeTest.java b/gson/src/test/java/com/google/gson/ParameterizedTypeTest.java
index 24d78e89..ca837c54 100644
--- a/gson/src/test/java/com/google/gson/ParameterizedTypeTest.java
+++ b/gson/src/test/java/com/google/gson/ParameterizedTypeTest.java
@@ -16,14 +16,15 @@
 
 package com.google.gson;
 
+import static com.google.common.truth.Truth.assertThat;
+
 import com.google.gson.internal.$Gson$Types;
 import com.google.gson.reflect.TypeToken;
-
-import junit.framework.TestCase;
-
 import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.Type;
 import java.util.List;
+import org.junit.Before;
+import org.junit.Test;
 
 /**
  * Unit tests for {@code ParameterizedType}s created by the {@link $Gson$Types} class.
@@ -31,27 +32,28 @@ import java.util.List;
  * @author Inderjeet Singh
  * @author Joel Leitch
  */
-public class ParameterizedTypeTest extends TestCase {
+public class ParameterizedTypeTest {
   private ParameterizedType ourType;
 
-  @Override
-  protected void setUp() throws Exception {
-    super.setUp();
+  @Before
+  public void setUp() throws Exception {
     ourType = $Gson$Types.newParameterizedTypeWithOwner(null, List.class, String.class);
   }
 
-  public void testOurTypeFunctionality() throws Exception {
+  @Test
+  public void testOurTypeFunctionality() {
     Type parameterizedType = new TypeToken<List<String>>() {}.getType();
-    assertNull(ourType.getOwnerType());
-    assertEquals(String.class, ourType.getActualTypeArguments()[0]);
-    assertEquals(List.class, ourType.getRawType());
-    assertEquals(parameterizedType, ourType);
-    assertEquals(parameterizedType.hashCode(), ourType.hashCode());
+    assertThat(ourType.getOwnerType()).isNull();
+    assertThat(ourType.getActualTypeArguments()[0]).isSameInstanceAs(String.class);
+    assertThat(ourType.getRawType()).isSameInstanceAs(List.class);
+    assertThat(ourType).isEqualTo(parameterizedType);
+    assertThat(ourType.hashCode()).isEqualTo(parameterizedType.hashCode());
   }
 
-  public void testNotEquals() throws Exception {
+  @Test
+  public void testNotEquals() {
     Type differentParameterizedType = new TypeToken<List<Integer>>() {}.getType();
-    assertFalse(differentParameterizedType.equals(ourType));
-    assertFalse(ourType.equals(differentParameterizedType));
+    assertThat(differentParameterizedType.equals(ourType)).isFalse();
+    assertThat(ourType.equals(differentParameterizedType)).isFalse();
   }
 }
diff --git a/gson/src/test/java/com/google/gson/ToNumberPolicyTest.java b/gson/src/test/java/com/google/gson/ToNumberPolicyTest.java
index 066a1521..363e144d 100644
--- a/gson/src/test/java/com/google/gson/ToNumberPolicyTest.java
+++ b/gson/src/test/java/com/google/gson/ToNumberPolicyTest.java
@@ -16,24 +16,28 @@
 
 package com.google.gson;
 
-import java.io.IOException;
-import java.io.StringReader;
-import java.math.BigDecimal;
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.fail;
+
 import com.google.gson.internal.LazilyParsedNumber;
 import com.google.gson.stream.JsonReader;
 import com.google.gson.stream.MalformedJsonException;
-import junit.framework.TestCase;
+import java.io.IOException;
+import java.io.StringReader;
+import java.math.BigDecimal;
+import org.junit.Test;
 
-public class ToNumberPolicyTest extends TestCase {
+public class ToNumberPolicyTest {
+  @Test
   public void testDouble() throws IOException {
     ToNumberStrategy strategy = ToNumberPolicy.DOUBLE;
-    assertEquals(10.1, strategy.readNumber(fromString("10.1")));
-    assertEquals(3.141592653589793D, strategy.readNumber(fromString("3.141592653589793238462643383279")));
+    assertThat(strategy.readNumber(fromString("10.1"))).isEqualTo(10.1);
+    assertThat(strategy.readNumber(fromString("3.141592653589793238462643383279"))).isEqualTo(3.141592653589793D);
     try {
       strategy.readNumber(fromString("1e400"));
       fail();
     } catch (MalformedJsonException expected) {
-      assertEquals("JSON forbids NaN and infinities: Infinity at line 1 column 6 (char '\0') path $", expected.getMessage());
+      assertThat(expected).hasMessageThat().isEqualTo("JSON forbids NaN and infinities: Infinity at line 1 column 6 (char '\0') path $");
     }
     try {
       strategy.readNumber(fromString("\"not-a-number\""));
@@ -42,68 +46,72 @@ public class ToNumberPolicyTest extends TestCase {
     }
   }
 
+  @Test
   public void testLazilyParsedNumber() throws IOException {
     ToNumberStrategy strategy = ToNumberPolicy.LAZILY_PARSED_NUMBER;
-    assertEquals(new LazilyParsedNumber("10.1"), strategy.readNumber(fromString("10.1")));
-    assertEquals(new LazilyParsedNumber("3.141592653589793238462643383279"), strategy.readNumber(fromString("3.141592653589793238462643383279")));
-    assertEquals(new LazilyParsedNumber("1e400"), strategy.readNumber(fromString("1e400")));
+    assertThat(strategy.readNumber(fromString("10.1"))).isEqualTo(new LazilyParsedNumber("10.1"));
+    assertThat(strategy.readNumber(fromString("3.141592653589793238462643383279"))).isEqualTo(new LazilyParsedNumber("3.141592653589793238462643383279"));
+    assertThat(strategy.readNumber(fromString("1e400"))).isEqualTo(new LazilyParsedNumber("1e400"));
   }
 
+  @Test
   public void testLongOrDouble() throws IOException {
     ToNumberStrategy strategy = ToNumberPolicy.LONG_OR_DOUBLE;
-    assertEquals(10L, strategy.readNumber(fromString("10")));
-    assertEquals(10.1, strategy.readNumber(fromString("10.1")));
-    assertEquals(3.141592653589793D, strategy.readNumber(fromString("3.141592653589793238462643383279")));
+    assertThat(strategy.readNumber(fromString("10"))).isEqualTo(10L);
+    assertThat(strategy.readNumber(fromString("10.1"))).isEqualTo(10.1);
+    assertThat(strategy.readNumber(fromString("3.141592653589793238462643383279"))).isEqualTo(3.141592653589793D);
     try {
       strategy.readNumber(fromString("1e400"));
       fail();
     } catch (MalformedJsonException expected) {
-      assertEquals("JSON forbids NaN and infinities: Infinity; at path $", expected.getMessage());
+      assertThat(expected).hasMessageThat().isEqualTo("JSON forbids NaN and infinities: Infinity; at path $");
     }
     try {
       strategy.readNumber(fromString("\"not-a-number\""));
       fail();
     } catch (JsonParseException expected) {
-      assertEquals("Cannot parse not-a-number; at path $", expected.getMessage());
+      assertThat(expected).hasMessageThat().isEqualTo("Cannot parse not-a-number; at path $");
     }
 
-    assertEquals(Double.NaN, strategy.readNumber(fromStringLenient("NaN")));
-    assertEquals(Double.POSITIVE_INFINITY, strategy.readNumber(fromStringLenient("Infinity")));
-    assertEquals(Double.NEGATIVE_INFINITY, strategy.readNumber(fromStringLenient("-Infinity")));
+    assertThat(strategy.readNumber(fromStringLenient("NaN"))).isEqualTo(Double.NaN);
+    assertThat(strategy.readNumber(fromStringLenient("Infinity"))).isEqualTo(Double.POSITIVE_INFINITY);
+    assertThat(strategy.readNumber(fromStringLenient("-Infinity"))).isEqualTo(Double.NEGATIVE_INFINITY);
     try {
       strategy.readNumber(fromString("NaN"));
       fail();
     } catch (MalformedJsonException expected) {
-      assertEquals("Use JsonReader.setLenient(true) to accept malformed JSON at line 1 column 1 (char 'N') path $", expected.getMessage());
+      assertThat(expected).hasMessageThat().isEqualTo("Use JsonReader.setLenient(true) to accept malformed JSON at line 1 column 1 (char 'N') path $");
     }
     try {
       strategy.readNumber(fromString("Infinity"));
       fail();
     } catch (MalformedJsonException expected) {
-      assertEquals("Use JsonReader.setLenient(true) to accept malformed JSON at line 1 column 1 (char 'I') path $", expected.getMessage());
+      assertThat(expected).hasMessageThat().isEqualTo("Use JsonReader.setLenient(true) to accept malformed JSON at line 1 column 1 (char 'I') path $");
     }
     try {
       strategy.readNumber(fromString("-Infinity"));
       fail();
     } catch (MalformedJsonException expected) {
-      assertEquals("Use JsonReader.setLenient(true) to accept malformed JSON at line 1 column 1 (char '-') path $", expected.getMessage());
+      assertThat(expected).hasMessageThat().isEqualTo("Use JsonReader.setLenient(true) to accept malformed JSON at line 1 column 1 (char '-') path $");
     }
   }
 
+  @Test
   public void testBigDecimal() throws IOException {
     ToNumberStrategy strategy = ToNumberPolicy.BIG_DECIMAL;
-    assertEquals(new BigDecimal("10.1"), strategy.readNumber(fromString("10.1")));
-    assertEquals(new BigDecimal("3.141592653589793238462643383279"), strategy.readNumber(fromString("3.141592653589793238462643383279")));
-    assertEquals(new BigDecimal("1e400"), strategy.readNumber(fromString("1e400")));
+    assertThat(strategy.readNumber(fromString("10.1"))).isEqualTo(new BigDecimal("10.1"));
+    assertThat(strategy.readNumber(fromString("3.141592653589793238462643383279"))).isEqualTo(new BigDecimal("3.141592653589793238462643383279"));
+    assertThat(strategy.readNumber(fromString("1e400"))).isEqualTo(new BigDecimal("1e400"));
 
     try {
       strategy.readNumber(fromString("\"not-a-number\""));
       fail();
     } catch (JsonParseException expected) {
-      assertEquals("Cannot parse not-a-number; at path $", expected.getMessage());
+      assertThat(expected).hasMessageThat().isEqualTo("Cannot parse not-a-number; at path $");
     }
   }
 
+  @Test
   public void testNullsAreNeverExpected() throws IOException {
     try {
       ToNumberPolicy.DOUBLE.readNumber(fromString("null"));
diff --git a/gson/src/test/java/com/google/gson/TypeAdapterTest.java b/gson/src/test/java/com/google/gson/TypeAdapterTest.java
index 725ecdae..97aaedfb 100644
--- a/gson/src/test/java/com/google/gson/TypeAdapterTest.java
+++ b/gson/src/test/java/com/google/gson/TypeAdapterTest.java
@@ -1,7 +1,6 @@
 package com.google.gson;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNull;
+import static com.google.common.truth.Truth.assertThat;
 import static org.junit.Assert.fail;
 
 import com.google.gson.stream.JsonReader;
@@ -23,8 +22,8 @@ public class TypeAdapterTest {
       }
     }.nullSafe();
 
-    assertEquals("null", adapter.toJson(null));
-    assertNull(adapter.fromJson("null"));
+    assertThat(adapter.toJson(null)).isEqualTo("null");
+    assertThat(adapter.fromJson("null")).isNull();
   }
 
   /**
@@ -39,7 +38,7 @@ public class TypeAdapterTest {
         throw exception;
       }
 
-      @Override public Integer read(JsonReader in) throws IOException {
+      @Override public Integer read(JsonReader in) {
         throw new AssertionError("not needed by this test");
       }
     };
@@ -48,14 +47,14 @@ public class TypeAdapterTest {
       adapter.toJson(1);
       fail();
     } catch (JsonIOException e) {
-      assertEquals(exception, e.getCause());
+      assertThat(e.getCause()).isEqualTo(exception);
     }
 
     try {
       adapter.toJsonTree(1);
       fail();
     } catch (JsonIOException e) {
-      assertEquals(exception, e.getCause());
+      assertThat(e.getCause()).isEqualTo(exception);
     }
   }
 
@@ -73,13 +72,13 @@ public class TypeAdapterTest {
   // whether that behavior is actually desired
   @Test
   public void testFromJson_Reader_TrailingData() throws IOException {
-    assertEquals("a", adapter.fromJson(new StringReader("\"a\"1")));
+    assertThat(adapter.fromJson(new StringReader("\"a\"1"))).isEqualTo("a");
   }
 
   // Note: This test just verifies the current behavior; it is a bit questionable
   // whether that behavior is actually desired
   @Test
   public void testFromJson_String_TrailingData() throws IOException {
-    assertEquals("a", adapter.fromJson("\"a\"1"));
+    assertThat(adapter.fromJson("\"a\"1")).isEqualTo("a");
   }
 }
diff --git a/gson/src/test/java/com/google/gson/VersionExclusionStrategyTest.java b/gson/src/test/java/com/google/gson/VersionExclusionStrategyTest.java
index 2b3fbafa..9ae8c656 100644
--- a/gson/src/test/java/com/google/gson/VersionExclusionStrategyTest.java
+++ b/gson/src/test/java/com/google/gson/VersionExclusionStrategyTest.java
@@ -16,8 +16,7 @@
 
 package com.google.gson;
 
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+import static com.google.common.truth.Truth.assertThat;
 
 import com.google.gson.annotations.Since;
 import com.google.gson.annotations.Until;
@@ -35,41 +34,41 @@ public class VersionExclusionStrategyTest {
   @Test
   public void testSameVersion() throws Exception {
     Excluder excluder = Excluder.DEFAULT.withVersion(VERSION);
-    assertFalse(excluder.excludeClass(MockClassSince.class, true));
-    assertFalse(excluder.excludeField(MockClassSince.class.getField("someField"), true));
+    assertThat(excluder.excludeClass(MockClassSince.class, true)).isFalse();
+    assertThat(excluder.excludeField(MockClassSince.class.getField("someField"), true)).isFalse();
 
     // Until version is exclusive
-    assertTrue(excluder.excludeClass(MockClassUntil.class, true));
-    assertTrue(excluder.excludeField(MockClassUntil.class.getField("someField"), true));
+    assertThat(excluder.excludeClass(MockClassUntil.class, true)).isTrue();
+    assertThat(excluder.excludeField(MockClassUntil.class.getField("someField"), true)).isTrue();
 
-    assertFalse(excluder.excludeClass(MockClassBoth.class, true));
-    assertFalse(excluder.excludeField(MockClassBoth.class.getField("someField"), true));
+    assertThat(excluder.excludeClass(MockClassBoth.class, true)).isFalse();
+    assertThat(excluder.excludeField(MockClassBoth.class.getField("someField"), true)).isFalse();
   }
 
   @Test
   public void testNewerVersion() throws Exception {
     Excluder excluder = Excluder.DEFAULT.withVersion(VERSION + 5);
-    assertFalse(excluder.excludeClass(MockClassSince.class, true));
-    assertFalse(excluder.excludeField(MockClassSince.class.getField("someField"), true));
+    assertThat(excluder.excludeClass(MockClassSince.class, true)).isFalse();
+    assertThat(excluder.excludeField(MockClassSince.class.getField("someField"), true)).isFalse();
 
-    assertTrue(excluder.excludeClass(MockClassUntil.class, true));
-    assertTrue(excluder.excludeField(MockClassUntil.class.getField("someField"), true));
+    assertThat(excluder.excludeClass(MockClassUntil.class, true)).isTrue();
+    assertThat(excluder.excludeField(MockClassUntil.class.getField("someField"), true)).isTrue();
 
-    assertTrue(excluder.excludeClass(MockClassBoth.class, true));
-    assertTrue(excluder.excludeField(MockClassBoth.class.getField("someField"), true));
+    assertThat(excluder.excludeClass(MockClassBoth.class, true)).isTrue();
+    assertThat(excluder.excludeField(MockClassBoth.class.getField("someField"), true)).isTrue();
   }
 
   @Test
   public void testOlderVersion() throws Exception {
     Excluder excluder = Excluder.DEFAULT.withVersion(VERSION - 5);
-    assertTrue(excluder.excludeClass(MockClassSince.class, true));
-    assertTrue(excluder.excludeField(MockClassSince.class.getField("someField"), true));
+    assertThat(excluder.excludeClass(MockClassSince.class, true)).isTrue();
+    assertThat(excluder.excludeField(MockClassSince.class.getField("someField"), true)).isTrue();
 
-    assertFalse(excluder.excludeClass(MockClassUntil.class, true));
-    assertFalse(excluder.excludeField(MockClassUntil.class.getField("someField"), true));
+    assertThat(excluder.excludeClass(MockClassUntil.class, true)).isFalse();
+    assertThat(excluder.excludeField(MockClassUntil.class.getField("someField"), true)).isFalse();
 
-    assertTrue(excluder.excludeClass(MockClassBoth.class, true));
-    assertTrue(excluder.excludeField(MockClassBoth.class.getField("someField"), true));
+    assertThat(excluder.excludeClass(MockClassBoth.class, true)).isTrue();
+    assertThat(excluder.excludeField(MockClassBoth.class.getField("someField"), true)).isTrue();
   }
 
   @Since(VERSION)
diff --git a/gson/src/test/java/com/google/gson/functional/ArrayTest.java b/gson/src/test/java/com/google/gson/functional/ArrayTest.java
index 8438391f..04a96491 100644
--- a/gson/src/test/java/com/google/gson/functional/ArrayTest.java
+++ b/gson/src/test/java/com/google/gson/functional/ArrayTest.java
@@ -17,6 +17,10 @@
 package com.google.gson.functional;
 
 import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
 
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
@@ -28,33 +32,36 @@ import java.lang.reflect.Type;
 import java.math.BigDecimal;
 import java.util.ArrayList;
 import java.util.Collection;
-import junit.framework.TestCase;
+import org.junit.Before;
+import org.junit.Test;
 /**
  * Functional tests for Json serialization and deserialization of arrays.
  *
  * @author Inderjeet Singh
  * @author Joel Leitch
  */
-public class ArrayTest extends TestCase {
+public class ArrayTest {
   private Gson gson;
 
-  @Override
-  protected void setUp() throws Exception {
-    super.setUp();
+  @Before
+  public void setUp() throws Exception {
     gson = new Gson();
   }
 
+  @Test
   public void testTopLevelArrayOfIntsSerialization() {
     int[] target = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     assertEquals("[1,2,3,4,5,6,7,8,9]", gson.toJson(target));
   }
 
+  @Test
   public void testTopLevelArrayOfIntsDeserialization() {
     int[] expected = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     int[] actual = gson.fromJson("[1,2,3,4,5,6,7,8,9]", int[].class);
     assertArrayEquals(expected, actual);
   }
 
+  @Test
   public void testInvalidArrayDeserialization() {
     String json = "[1, 2 3, 4, 5]";
     try {
@@ -64,11 +71,13 @@ public class ArrayTest extends TestCase {
     }
   }
 
+  @Test
   public void testEmptyArraySerialization() {
     int[] target = {};
     assertEquals("[]", gson.toJson(target));
   }
 
+  @Test
   public void testEmptyArrayDeserialization() {
     int[] actualObject = gson.fromJson("[]", int[].class);
     assertTrue(actualObject.length == 0);
@@ -80,6 +89,7 @@ public class ArrayTest extends TestCase {
     assertTrue(actualObject.length == 0);
   }
 
+  @Test
   public void testNullsInArraySerialization() {
     String[] array = {"foo", null, "bar"};
     String expected = "[\"foo\",null,\"bar\"]";
@@ -87,6 +97,7 @@ public class ArrayTest extends TestCase {
     assertEquals(expected, json);
   }
 
+  @Test
   public void testNullsInArrayDeserialization() {
     String json = "[\"foo\",null,\"bar\"]";
     String[] expected = {"foo", null, "bar"};
@@ -96,6 +107,7 @@ public class ArrayTest extends TestCase {
     }
   }
 
+  @Test
   public void testSingleNullInArraySerialization() {
     BagOfPrimitives[] array = new BagOfPrimitives[1];
     array[0] = null;
@@ -103,11 +115,13 @@ public class ArrayTest extends TestCase {
     assertEquals("[null]", json);
   }
 
+  @Test
   public void testSingleNullInArrayDeserialization() {
     BagOfPrimitives[] array = gson.fromJson("[null]", BagOfPrimitives[].class);
     assertNull(array[0]);
   }
 
+  @Test
   public void testNullsInArrayWithSerializeNullPropertySetSerialization() {
     gson = new GsonBuilder().serializeNulls().create();
     String[] array = {"foo", null, "bar"};
@@ -116,11 +130,13 @@ public class ArrayTest extends TestCase {
     assertEquals(expected, json);
   }
 
+  @Test
   public void testArrayOfStringsSerialization() {
     String[] target = {"Hello", "World"};
     assertEquals("[\"Hello\",\"World\"]", gson.toJson(target));
   }
 
+  @Test
   public void testArrayOfStringsDeserialization() {
     String json = "[\"Hello\",\"World\"]";
     String[] target = gson.fromJson(json, String[].class);
@@ -128,12 +144,14 @@ public class ArrayTest extends TestCase {
     assertEquals("World", target[1]);
   }
 
+  @Test
   public void testSingleStringArraySerialization() throws Exception {
     String[] s = { "hello" };
     String output = gson.toJson(s);
     assertEquals("[\"hello\"]", output);
   }
 
+  @Test
   public void testSingleStringArrayDeserialization() throws Exception {
     String json = "[\"hello\"]";
     String[] arrayType = gson.fromJson(json, String[].class);
@@ -141,6 +159,7 @@ public class ArrayTest extends TestCase {
     assertEquals("hello", arrayType[0]);
   }
 
+  @Test
   public void testArrayOfCollectionSerialization() throws Exception {
     StringBuilder sb = new StringBuilder("[");
     int arraySize = 3;
@@ -166,6 +185,7 @@ public class ArrayTest extends TestCase {
     assertEquals(sb.toString(), json);
   }
 
+  @Test
   public void testArrayOfCollectionDeserialization() throws Exception {
     String json = "[[1,2],[3,4]]";
     Type type = new TypeToken<Collection<Integer>[]>() {}.getType();
@@ -176,6 +196,7 @@ public class ArrayTest extends TestCase {
     assertArrayEquals(new Integer[] {3, 4}, target[1].toArray(new Integer[0]));
   }
 
+  @Test
   public void testArrayOfPrimitivesAsObjectsSerialization() throws Exception {
     Object[] objs = new Object[] {1, "abc", 0.3f, 5L};
     String json = gson.toJson(objs);
@@ -184,16 +205,18 @@ public class ArrayTest extends TestCase {
     assertTrue(json.contains("5"));
   }
 
+  @Test
   public void testArrayOfPrimitivesAsObjectsDeserialization() throws Exception {
     String json = "[1,\"abc\",0.3,1.1,5]";
     Object[] objs = gson.fromJson(json, Object[].class);
     assertEquals(1, ((Number)objs[0]).intValue());
     assertEquals("abc", objs[1]);
-    assertEquals(0.3, ((Number)objs[2]).doubleValue());
+    assertEquals(0.3, ((Number)objs[2]).doubleValue(), 0);
     assertEquals(new BigDecimal("1.1"), new BigDecimal(objs[3].toString()));
     assertEquals(5, ((Number)objs[4]).shortValue());
   }
 
+  @Test
   public void testObjectArrayWithNonPrimitivesSerialization() throws Exception {
     ClassWithObjects classWithObjects = new ClassWithObjects();
     BagOfPrimitives bagOfPrimitives = new BagOfPrimitives();
@@ -207,12 +230,14 @@ public class ArrayTest extends TestCase {
     assertTrue(json.contains(bagOfPrimitivesJson));
   }
 
+  @Test
   public void testArrayOfNullSerialization() {
     Object[] array = {null};
     String json = gson.toJson(array);
     assertEquals("[null]", json);
   }
 
+  @Test
   public void testArrayOfNullDeserialization() {
     String[] values = gson.fromJson("[null]", String[].class);
     assertNull(values[0]);
@@ -221,6 +246,7 @@ public class ArrayTest extends TestCase {
   /**
    * Regression tests for Issue 272
    */
+  @Test
   public void testMultidimensionalArraysSerialization() {
     String[][] items = {
         {"3m Co", "71.72", "0.02", "0.03", "4/2 12:00am", "Manufacturing"},
@@ -231,11 +257,13 @@ public class ArrayTest extends TestCase {
     assertTrue(json.contains("Manufacturing\"]]"));
   }
 
+  @Test
   public void testMultidimensionalObjectArraysSerialization() {
     Object[][] array = {new Object[] { 1, 2 }};
     assertEquals("[[1,2]]", gson.toJson(array));
   }
 
+  @Test
   public void testMultidimensionalPrimitiveArraysSerialization() {
     int[][] array = {{1, 2}, {3, 4}};
     assertEquals("[[1,2],[3,4]]", gson.toJson(array));
@@ -244,6 +272,7 @@ public class ArrayTest extends TestCase {
   /**
    * Regression test for Issue 205
    */
+  @Test
   public void testMixingTypesInObjectArraySerialization() {
     Object[] array = {1, 2, new Object[] {"one", "two", 3}};
     assertEquals("[1,2,[\"one\",\"two\",3]]", gson.toJson(array));
@@ -252,6 +281,7 @@ public class ArrayTest extends TestCase {
   /**
    * Regression tests for Issue 272
    */
+  @Test
   public void testMultidimensionalArraysDeserialization() {
     String json = "[[\"3m Co\",\"71.72\",\"0.02\",\"0.03\",\"4/2 12:00am\",\"Manufacturing\"],"
       + "[\"Alcoa Inc\",\"29.01\",\"0.42\",\"1.47\",\"4/1 12:00am\",\"Manufacturing\"]]";
@@ -260,6 +290,7 @@ public class ArrayTest extends TestCase {
     assertEquals("Manufacturing", items[1][5]);
   }
 
+  @Test
   public void testMultidimensionalPrimitiveArraysDeserialization() {
     String json = "[[1,2],[3,4]]";
     int[][] expected = {{1, 2}, {3, 4}};
@@ -267,6 +298,7 @@ public class ArrayTest extends TestCase {
   }
 
   /** http://code.google.com/p/google-gson/issues/detail?id=342 */
+  @Test
   public void testArrayElementsAreArrays() {
     Object[] stringArrays = {
         new String[] {"test1", "test2"},
diff --git a/gson/src/test/java/com/google/gson/functional/CircularReferenceTest.java b/gson/src/test/java/com/google/gson/functional/CircularReferenceTest.java
index f4419551..053d8b46 100644
--- a/gson/src/test/java/com/google/gson/functional/CircularReferenceTest.java
+++ b/gson/src/test/java/com/google/gson/functional/CircularReferenceTest.java
@@ -15,11 +15,10 @@
  */
 package com.google.gson.functional;
 
-import java.lang.reflect.Type;
-import java.util.ArrayList;
-import java.util.Collection;
-
-import junit.framework.TestCase;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.fail;
 
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
@@ -28,6 +27,11 @@ import com.google.gson.JsonObject;
 import com.google.gson.JsonSerializationContext;
 import com.google.gson.JsonSerializer;
 import com.google.gson.common.TestTypes.ClassOverridingEquals;
+import java.lang.reflect.Type;
+import java.util.ArrayList;
+import java.util.Collection;
+import org.junit.Before;
+import org.junit.Test;
 
 /**
  * Functional tests related to circular reference detection and error reporting.
@@ -35,15 +39,15 @@ import com.google.gson.common.TestTypes.ClassOverridingEquals;
  * @author Inderjeet Singh
  * @author Joel Leitch
  */
-public class CircularReferenceTest extends TestCase {
+public class CircularReferenceTest {
   private Gson gson;
 
-  @Override
-  protected void setUp() throws Exception {
-    super.setUp();
+  @Before
+  public void setUp() throws Exception {
     gson = new Gson();
   }
 
+  @Test
   public void testCircularSerialization() throws Exception {
     ContainsReferenceToSelfType a = new ContainsReferenceToSelfType();
     ContainsReferenceToSelfType b = new ContainsReferenceToSelfType();
@@ -56,6 +60,7 @@ public class CircularReferenceTest extends TestCase {
     }
   }
 
+  @Test
   public void testSelfReferenceIgnoredInSerialization() throws Exception {
     ClassOverridingEquals objA = new ClassOverridingEquals();
     objA.ref = objA;
@@ -64,6 +69,7 @@ public class CircularReferenceTest extends TestCase {
     assertFalse(json.contains("ref")); // self-reference is ignored
   }
 
+  @Test
   public void testSelfReferenceArrayFieldSerialization() throws Exception {
     ClassWithSelfReferenceArray objA = new ClassWithSelfReferenceArray();
     objA.children = new ClassWithSelfReferenceArray[]{objA};
@@ -75,6 +81,7 @@ public class CircularReferenceTest extends TestCase {
     }
   }
 
+  @Test
   public void testSelfReferenceCustomHandlerSerialization() throws Exception {
     ClassWithSelfReference obj = new ClassWithSelfReference();
     obj.child = obj;
@@ -94,6 +101,7 @@ public class CircularReferenceTest extends TestCase {
     }
   }
 
+  @Test
   public void testDirectedAcyclicGraphSerialization() throws Exception {
     ContainsReferenceToSelfType a = new ContainsReferenceToSelfType();
     ContainsReferenceToSelfType b = new ContainsReferenceToSelfType();
@@ -104,6 +112,7 @@ public class CircularReferenceTest extends TestCase {
     assertNotNull(gson.toJson(a));
   }
 
+  @Test
   public void testDirectedAcyclicGraphDeserialization() throws Exception {
     String json = "{\"children\":[{\"children\":[{\"children\":[]}]},{\"children\":[]}]}";
     ContainsReferenceToSelfType target = gson.fromJson(json, ContainsReferenceToSelfType.class);
diff --git a/gson/src/test/java/com/google/gson/functional/CollectionTest.java b/gson/src/test/java/com/google/gson/functional/CollectionTest.java
index 9bdf2d85..bcfd34c9 100644
--- a/gson/src/test/java/com/google/gson/functional/CollectionTest.java
+++ b/gson/src/test/java/com/google/gson/functional/CollectionTest.java
@@ -17,6 +17,9 @@
 package com.google.gson.functional;
 
 import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
 
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
@@ -40,7 +43,8 @@ import java.util.Queue;
 import java.util.Set;
 import java.util.Stack;
 import java.util.Vector;
-import junit.framework.TestCase;
+import org.junit.Before;
+import org.junit.Test;
 
 /**
  * Functional tests for Json serialization and deserialization of collections.
@@ -48,15 +52,15 @@ import junit.framework.TestCase;
  * @author Inderjeet Singh
  * @author Joel Leitch
  */
-public class CollectionTest extends TestCase {
+public class CollectionTest {
   private Gson gson;
 
-  @Override
-  protected void setUp() throws Exception {
-    super.setUp();
+  @Before
+  public void setUp() throws Exception {
     gson = new Gson();
   }
 
+  @Test
   public void testTopLevelCollectionOfIntegersSerialization() {
     Collection<Integer> target = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
     Type targetType = new TypeToken<Collection<Integer>>() {}.getType();
@@ -64,6 +68,7 @@ public class CollectionTest extends TestCase {
     assertEquals("[1,2,3,4,5,6,7,8,9]", json);
   }
 
+  @Test
   public void testTopLevelCollectionOfIntegersDeserialization() {
     String json = "[0,1,2,3,4,5,6,7,8,9]";
     Type collectionType = new TypeToken<Collection<Integer>>() { }.getType();
@@ -72,6 +77,7 @@ public class CollectionTest extends TestCase {
     assertArrayEquals(expected, toIntArray(target));
   }
 
+  @Test
   public void testTopLevelListOfIntegerCollectionsDeserialization() throws Exception {
     String json = "[[1,2,3],[4,5,6],[7,8,9]]";
     Type collectionType = new TypeToken<Collection<Collection<Integer>>>() {}.getType();
@@ -89,6 +95,7 @@ public class CollectionTest extends TestCase {
     }
   }
 
+  @Test
   public void testLinkedListSerialization() {
     List<String> list = new LinkedList<>();
     list.add("a1");
@@ -99,6 +106,7 @@ public class CollectionTest extends TestCase {
     assertTrue(json.contains("a2"));
   }
 
+  @Test
   public void testLinkedListDeserialization() {
     String json = "[\"a1\",\"a2\"]";
     Type linkedListType = new TypeToken<LinkedList<String>>() {}.getType();
@@ -107,6 +115,7 @@ public class CollectionTest extends TestCase {
     assertEquals("a2", list.get(1));
   }
 
+  @Test
   public void testQueueSerialization() {
     Queue<String> queue = new LinkedList<>();
     queue.add("a1");
@@ -117,6 +126,7 @@ public class CollectionTest extends TestCase {
     assertTrue(json.contains("a2"));
   }
 
+  @Test
   public void testQueueDeserialization() {
     String json = "[\"a1\",\"a2\"]";
     Type queueType = new TypeToken<Queue<String>>() {}.getType();
@@ -126,6 +136,7 @@ public class CollectionTest extends TestCase {
     assertEquals("a2", queue.element());
   }
 
+  @Test
   public void testPriorityQueue() throws Exception {
     Type type = new TypeToken<PriorityQueue<Integer>>(){}.getType();
     PriorityQueue<Integer> queue = gson.fromJson("[10, 20, 22]", type);
@@ -137,6 +148,7 @@ public class CollectionTest extends TestCase {
     assertEquals("[10,20,22]", json);
   }
 
+  @Test
   public void testVector() {
     Type type = new TypeToken<Vector<Integer>>(){}.getType();
     Vector<Integer> target = gson.fromJson("[10, 20, 31]", type);
@@ -148,6 +160,7 @@ public class CollectionTest extends TestCase {
     assertEquals("[10,20,31]", json);
   }
 
+  @Test
   public void testStack() {
     Type type = new TypeToken<Stack<Integer>>(){}.getType();
     Stack<Integer> target = gson.fromJson("[11, 13, 17]", type);
@@ -159,6 +172,7 @@ public class CollectionTest extends TestCase {
     assertEquals("[11,13,17]", json);
   }
 
+  @Test
   public void testNullsInListSerialization() {
     List<String> list = new ArrayList<>();
     list.add("foo");
@@ -170,6 +184,7 @@ public class CollectionTest extends TestCase {
     assertEquals(expected, json);
   }
 
+  @Test
   public void testNullsInListDeserialization() {
     List<String> expected = new ArrayList<>();
     expected.add("foo");
@@ -183,6 +198,7 @@ public class CollectionTest extends TestCase {
     }
   }
 
+  @Test
   public void testCollectionOfObjectSerialization() {
     List<Object> target = new ArrayList<>();
     target.add("Hello");
@@ -193,6 +209,7 @@ public class CollectionTest extends TestCase {
     assertEquals("[\"Hello\",\"World\"]", gson.toJson(target, type));
   }
 
+  @Test
   public void testCollectionOfObjectWithNullSerialization() {
     List<Object> target = new ArrayList<>();
     target.add("Hello");
@@ -204,6 +221,7 @@ public class CollectionTest extends TestCase {
     assertEquals("[\"Hello\",null,\"World\"]", gson.toJson(target, type));
   }
 
+  @Test
   public void testCollectionOfStringsSerialization() {
     List<String> target = new ArrayList<>();
     target.add("Hello");
@@ -211,6 +229,7 @@ public class CollectionTest extends TestCase {
     assertEquals("[\"Hello\",\"World\"]", gson.toJson(target));
   }
 
+  @Test
   public void testCollectionOfBagOfPrimitivesSerialization() {
     List<BagOfPrimitives> target = new ArrayList<>();
     BagOfPrimitives objA = new BagOfPrimitives(3L, 1, true, "blah");
@@ -226,6 +245,7 @@ public class CollectionTest extends TestCase {
     }
   }
 
+  @Test
   public void testCollectionOfStringsDeserialization() {
     String json = "[\"Hello\",\"World\"]";
     Type collectionType = new TypeToken<Collection<String>>() { }.getType();
@@ -235,11 +255,13 @@ public class CollectionTest extends TestCase {
     assertTrue(target.contains("World"));
   }
 
+  @Test
   public void testRawCollectionOfIntegersSerialization() {
     Collection<Integer> target = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
     assertEquals("[1,2,3,4,5,6,7,8,9]", gson.toJson(target));
   }
 
+  @Test
   public void testObjectCollectionSerialization() {
     BagOfPrimitives bag1 = new BagOfPrimitives();
     Collection<?> target = Arrays.asList(bag1, bag1, "test");
@@ -247,6 +269,7 @@ public class CollectionTest extends TestCase {
     assertTrue(json.contains(bag1.getExpectedJson()));
   }
 
+  @Test
   public void testRawCollectionDeserializationNotAlllowed() {
     String json = "[0,1,2,3,4,5,6,7,8,9]";
     Collection<?> integers = gson.fromJson(json, Collection.class);
@@ -259,6 +282,7 @@ public class CollectionTest extends TestCase {
     assertTrue(strings.contains("World"));
   }
 
+  @Test
   public void testRawCollectionOfBagOfPrimitivesNotAllowed() {
     BagOfPrimitives bag = new BagOfPrimitives(10, 20, false, "stringValue");
     String json = '[' + bag.getExpectedJson() + ',' + bag.getExpectedJson() + ']';
@@ -274,6 +298,7 @@ public class CollectionTest extends TestCase {
     }
   }
 
+  @Test
   public void testWildcardPrimitiveCollectionSerilaization() throws Exception {
     Collection<? extends Integer> target = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
     Type collectionType = new TypeToken<Collection<? extends Integer>>() { }.getType();
@@ -284,6 +309,7 @@ public class CollectionTest extends TestCase {
     assertEquals("[1,2,3,4,5,6,7,8,9]", json);
   }
 
+  @Test
   public void testWildcardPrimitiveCollectionDeserilaization() throws Exception {
     String json = "[1,2,3,4,5,6,7,8,9]";
     Type collectionType = new TypeToken<Collection<? extends Integer>>() { }.getType();
@@ -293,6 +319,7 @@ public class CollectionTest extends TestCase {
     assertTrue(target.contains(9));
   }
 
+  @Test
   public void testWildcardCollectionField() throws Exception {
     Collection<BagOfPrimitives> collection = new ArrayList<>();
     BagOfPrimitives objA = new BagOfPrimitives(3L, 1, true, "blah");
@@ -312,6 +339,7 @@ public class CollectionTest extends TestCase {
     assertTrue(deserializedCollection.contains(objB));
   }
 
+  @Test
   public void testFieldIsArrayList() {
     HasArrayListField object = new HasArrayListField();
     object.longs.add(1L);
@@ -322,6 +350,7 @@ public class CollectionTest extends TestCase {
     assertEquals(Arrays.asList(1L, 3L), copy.longs);
   }
 
+  @Test
   public void testUserCollectionTypeAdapter() {
     Type listOfString = new TypeToken<List<String>>() {}.getType();
     Object stringListSerializer = new JsonSerializer<List<String>>() {
@@ -372,6 +401,7 @@ public class CollectionTest extends TestCase {
       this.value = value;
     }
   }
+  @Test
   public void testSetSerialization() {
     Set<Entry> set = new HashSet<>();
     set.add(new Entry(1));
@@ -380,6 +410,7 @@ public class CollectionTest extends TestCase {
     assertTrue(json.contains("1"));
     assertTrue(json.contains("2"));
   }
+  @Test
   public void testSetDeserialization() {
     String json = "[{\"value\":1},{\"value\":2}]";
     Type type = new TypeToken<Set<Entry>>() {}.getType();
@@ -394,6 +425,7 @@ public class CollectionTest extends TestCase {
 
   private class SmallClass { private String inSmall; }
 
+  @Test
   public void testIssue1107() {
     String json = "{\n" +
             "  \"inBig\": {\n" +
diff --git a/gson/src/test/java/com/google/gson/functional/ConcurrencyTest.java b/gson/src/test/java/com/google/gson/functional/ConcurrencyTest.java
index 99963b63..711ddefb 100644
--- a/gson/src/test/java/com/google/gson/functional/ConcurrencyTest.java
+++ b/gson/src/test/java/com/google/gson/functional/ConcurrencyTest.java
@@ -15,14 +15,15 @@
  */
 package com.google.gson.functional;
 
+import static org.junit.Assert.assertFalse;
+
+import com.google.gson.Gson;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.atomic.AtomicBoolean;
-
-import junit.framework.TestCase;
-
-import com.google.gson.Gson;
+import org.junit.Before;
+import org.junit.Test;
 
 /**
  * Tests for ensuring Gson thread-safety.
@@ -30,12 +31,11 @@ import com.google.gson.Gson;
  * @author Inderjeet Singh
  * @author Joel Leitch
  */
-public class ConcurrencyTest extends TestCase {
+public class ConcurrencyTest {
   private Gson gson;
 
-  @Override
-  protected void setUp() throws Exception {
-    super.setUp();
+  @Before
+  public void setUp() throws Exception {
     gson = new Gson();
   }
 
@@ -43,6 +43,7 @@ public class ConcurrencyTest extends TestCase {
    * Source-code based on
    * http://groups.google.com/group/google-gson/browse_thread/thread/563bb51ee2495081
    */
+  @Test
   public void testSingleThreadSerialization() { 
     MyObject myObj = new MyObject(); 
     for (int i = 0; i < 10; i++) { 
@@ -54,6 +55,7 @@ public class ConcurrencyTest extends TestCase {
    * Source-code based on
    * http://groups.google.com/group/google-gson/browse_thread/thread/563bb51ee2495081
    */
+  @Test
   public void testSingleThreadDeserialization() { 
     for (int i = 0; i < 10; i++) { 
       gson.fromJson("{\"a\":\"hello\",\"b\":\"world\",\"i\":1}", MyObject.class);
@@ -64,6 +66,7 @@ public class ConcurrencyTest extends TestCase {
    * Source-code based on
    * http://groups.google.com/group/google-gson/browse_thread/thread/563bb51ee2495081
    */
+  @Test
   public void testMultiThreadSerialization() throws InterruptedException {
     final CountDownLatch startLatch = new CountDownLatch(1);
     final CountDownLatch finishedLatch = new CountDownLatch(10);
@@ -95,6 +98,7 @@ public class ConcurrencyTest extends TestCase {
    * Source-code based on
    * http://groups.google.com/group/google-gson/browse_thread/thread/563bb51ee2495081
    */
+  @Test
   public void testMultiThreadDeserialization() throws InterruptedException {
     final CountDownLatch startLatch = new CountDownLatch(1);
     final CountDownLatch finishedLatch = new CountDownLatch(10);
diff --git a/gson/src/test/java/com/google/gson/functional/CustomDeserializerTest.java b/gson/src/test/java/com/google/gson/functional/CustomDeserializerTest.java
index ca0ba1ee..3b72dc86 100644
--- a/gson/src/test/java/com/google/gson/functional/CustomDeserializerTest.java
+++ b/gson/src/test/java/com/google/gson/functional/CustomDeserializerTest.java
@@ -16,6 +16,9 @@
 
 package com.google.gson.functional;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
 import com.google.gson.JsonDeserializationContext;
@@ -25,10 +28,9 @@ import com.google.gson.JsonObject;
 import com.google.gson.JsonParseException;
 import com.google.gson.common.TestTypes.Base;
 import com.google.gson.common.TestTypes.ClassWithBaseField;
-
-import junit.framework.TestCase;
-
 import java.lang.reflect.Type;
+import org.junit.Before;
+import org.junit.Test;
 
 /**
  * Functional Test exercising custom deserialization only. When test applies to both
@@ -36,18 +38,18 @@ import java.lang.reflect.Type;
  *
  * @author Joel Leitch
  */
-public class CustomDeserializerTest extends TestCase {
+public class CustomDeserializerTest {
   private static final String DEFAULT_VALUE = "test123";
   private static final String SUFFIX = "blah";
 
   private Gson gson;
 
-  @Override
-  protected void setUp() throws Exception {
-    super.setUp();
+  @Before
+  public void setUp() throws Exception {
     gson = new GsonBuilder().registerTypeAdapter(DataHolder.class, new DataHolderDeserializer()).create();
   }
 
+  @Test
   public void testDefaultConstructorNotCalledOnObject() throws Exception {
     DataHolder data = new DataHolder(DEFAULT_VALUE);
     String json = gson.toJson(data);
@@ -56,6 +58,7 @@ public class CustomDeserializerTest extends TestCase {
     assertEquals(DEFAULT_VALUE + SUFFIX, actual.getData());
   }
 
+  @Test
   public void testDefaultConstructorNotCalledOnField() throws Exception {
     DataHolderWrapper dataWrapper = new DataHolderWrapper(new DataHolder(DEFAULT_VALUE));
     String json = gson.toJson(dataWrapper);
@@ -110,6 +113,7 @@ public class CustomDeserializerTest extends TestCase {
     }
   }
 
+  @Test
   public void testJsonTypeFieldBasedDeserialization() {
     String json = "{field1:'abc',field2:'def',__type__:'SUB_TYPE1'}";
     Gson gson = new GsonBuilder()
@@ -147,6 +151,7 @@ public class CustomDeserializerTest extends TestCase {
     String field2;
   }
 
+  @Test
   public void testCustomDeserializerReturnsNullForTopLevelObject() {
     Gson gson = new GsonBuilder()
             .setLenient()
@@ -156,6 +161,7 @@ public class CustomDeserializerTest extends TestCase {
     assertNull(target);
   }
 
+  @Test
   public void testCustomDeserializerReturnsNull() {
     Gson gson = new GsonBuilder()
             .setLenient()
@@ -165,6 +171,7 @@ public class CustomDeserializerTest extends TestCase {
     assertNull(target.base);
   }
 
+  @Test
   public void testCustomDeserializerReturnsNullForArrayElements() {
     Gson gson = new GsonBuilder()
             .setLenient()
@@ -175,6 +182,7 @@ public class CustomDeserializerTest extends TestCase {
     assertNull(target[1]);
   }
 
+  @Test
   public void testCustomDeserializerReturnsNullForArrayElementsForArrayField() {
     Gson gson = new GsonBuilder()
             .setLenient()
diff --git a/gson/src/test/java/com/google/gson/functional/CustomSerializerTest.java b/gson/src/test/java/com/google/gson/functional/CustomSerializerTest.java
index e04cb67c..3e450ac9 100644
--- a/gson/src/test/java/com/google/gson/functional/CustomSerializerTest.java
+++ b/gson/src/test/java/com/google/gson/functional/CustomSerializerTest.java
@@ -16,6 +16,9 @@
 
 package com.google.gson.functional;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
 import com.google.gson.JsonArray;
@@ -29,10 +32,8 @@ import com.google.gson.common.TestTypes.ClassWithBaseArrayField;
 import com.google.gson.common.TestTypes.ClassWithBaseField;
 import com.google.gson.common.TestTypes.Sub;
 import com.google.gson.common.TestTypes.SubSerializer;
-
-import junit.framework.TestCase;
-
 import java.lang.reflect.Type;
+import org.junit.Test;
 
 /**
  * Functional Test exercising custom serialization only.  When test applies to both
@@ -40,9 +41,10 @@ import java.lang.reflect.Type;
  *
  * @author Inderjeet Singh
  */
-public class CustomSerializerTest extends TestCase {
+public class CustomSerializerTest {
 
-   public void testBaseClassSerializerInvokedForBaseClassFields() {
+  @Test
+  public void testBaseClassSerializerInvokedForBaseClassFields() {
      Gson gson = new GsonBuilder()
          .registerTypeAdapter(Base.class, new BaseSerializer())
          .registerTypeAdapter(Sub.class, new SubSerializer())
@@ -53,7 +55,8 @@ public class CustomSerializerTest extends TestCase {
      assertEquals(BaseSerializer.NAME, base.get(Base.SERIALIZER_KEY).getAsString());
    }
 
-   public void testSubClassSerializerInvokedForBaseClassFieldsHoldingSubClassInstances() {
+  @Test
+  public void testSubClassSerializerInvokedForBaseClassFieldsHoldingSubClassInstances() {
      Gson gson = new GsonBuilder()
          .registerTypeAdapter(Base.class, new BaseSerializer())
          .registerTypeAdapter(Sub.class, new SubSerializer())
@@ -64,7 +67,8 @@ public class CustomSerializerTest extends TestCase {
      assertEquals(SubSerializer.NAME, base.get(Base.SERIALIZER_KEY).getAsString());
    }
 
-   public void testSubClassSerializerInvokedForBaseClassFieldsHoldingArrayOfSubClassInstances() {
+  @Test
+  public void testSubClassSerializerInvokedForBaseClassFieldsHoldingArrayOfSubClassInstances() {
      Gson gson = new GsonBuilder()
          .registerTypeAdapter(Base.class, new BaseSerializer())
          .registerTypeAdapter(Sub.class, new SubSerializer())
@@ -78,7 +82,8 @@ public class CustomSerializerTest extends TestCase {
      }
    }
 
-   public void testBaseClassSerializerInvokedForBaseClassFieldsHoldingSubClassInstances() {
+  @Test
+  public void testBaseClassSerializerInvokedForBaseClassFieldsHoldingSubClassInstances() {
      Gson gson = new GsonBuilder()
          .registerTypeAdapter(Base.class, new BaseSerializer())
          .create();
@@ -88,7 +93,8 @@ public class CustomSerializerTest extends TestCase {
      assertEquals(BaseSerializer.NAME, base.get(Base.SERIALIZER_KEY).getAsString());
    }
 
-   public void testSerializerReturnsNull() {
+  @Test
+  public void testSerializerReturnsNull() {
      Gson gson = new GsonBuilder()
        .registerTypeAdapter(Base.class, new JsonSerializer<Base>() {
          @Override public JsonElement serialize(Base src, Type typeOfSrc, JsonSerializationContext context) {
diff --git a/gson/src/test/java/com/google/gson/functional/CustomTypeAdaptersTest.java b/gson/src/test/java/com/google/gson/functional/CustomTypeAdaptersTest.java
index 247a1e0f..505cffae 100644
--- a/gson/src/test/java/com/google/gson/functional/CustomTypeAdaptersTest.java
+++ b/gson/src/test/java/com/google/gson/functional/CustomTypeAdaptersTest.java
@@ -15,6 +15,11 @@
  */
 package com.google.gson.functional;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
 import com.google.gson.InstanceCreator;
@@ -35,7 +40,9 @@ import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Map;
 import java.util.Set;
-import junit.framework.TestCase;
+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Test;
 
 /**
  * Functional tests for the support of custom serializer and deserializers.
@@ -43,15 +50,15 @@ import junit.framework.TestCase;
  * @author Inderjeet Singh
  * @author Joel Leitch
  */
-public class CustomTypeAdaptersTest extends TestCase {
+public class CustomTypeAdaptersTest {
   private GsonBuilder builder;
 
-  @Override
-  protected void setUp() throws Exception {
-    super.setUp();
+  @Before
+  public void setUp() throws Exception {
     builder = new GsonBuilder();
   }
 
+  @Test
   public void testCustomSerializers() {
     Gson gson = builder.registerTypeAdapter(
         ClassWithCustomTypeConverter.class, new JsonSerializer<ClassWithCustomTypeConverter>() {
@@ -67,6 +74,7 @@ public class CustomTypeAdaptersTest extends TestCase {
     assertEquals("{\"bag\":5,\"value\":25}", gson.toJson(target));
   }
 
+  @Test
   public void testCustomDeserializers() {
     Gson gson = new GsonBuilder().registerTypeAdapter(
         ClassWithCustomTypeConverter.class, new JsonDeserializer<ClassWithCustomTypeConverter>() {
@@ -83,6 +91,8 @@ public class CustomTypeAdaptersTest extends TestCase {
     assertEquals(5, target.getBag().getIntValue());
   }
 
+  @Test
+  @Ignore
   public void disable_testCustomSerializersOfSelf() {
     Gson gson = createGsonObjectWithFooTypeAdapter();
     Gson basicGson = new Gson();
@@ -93,6 +103,8 @@ public class CustomTypeAdaptersTest extends TestCase {
     assertEquals(jsonFromGson, jsonFromCustomSerializer);
   }
 
+  @Test
+  @Ignore
   public void disable_testCustomDeserializersOfSelf() {
     Gson gson = createGsonObjectWithFooTypeAdapter();
     Gson basicGson = new Gson();
@@ -104,6 +116,7 @@ public class CustomTypeAdaptersTest extends TestCase {
     assertEquals(expectedFoo.value, newFooObject.value);
   }
 
+  @Test
   public void testCustomNestedSerializers() {
     Gson gson = new GsonBuilder().registerTypeAdapter(
         BagOfPrimitives.class, new JsonSerializer<BagOfPrimitives>() {
@@ -116,6 +129,7 @@ public class CustomTypeAdaptersTest extends TestCase {
     assertEquals("{\"bag\":6,\"value\":10}", gson.toJson(target));
   }
 
+  @Test
   public void testCustomNestedDeserializers() {
     Gson gson = new GsonBuilder().registerTypeAdapter(
         BagOfPrimitives.class, new JsonDeserializer<BagOfPrimitives>() {
@@ -130,6 +144,7 @@ public class CustomTypeAdaptersTest extends TestCase {
     assertEquals(7, target.getBag().getIntValue());
   }
 
+  @Test
   public void testCustomTypeAdapterDoesNotAppliesToSubClasses() {
     Gson gson = new GsonBuilder().registerTypeAdapter(Base.class, new JsonSerializer<Base> () {
       @Override
@@ -147,6 +162,7 @@ public class CustomTypeAdaptersTest extends TestCase {
     assertTrue(json.contains("derivedValue"));
   }
 
+  @Test
   public void testCustomTypeAdapterAppliesToSubClassesSerializedAsBaseClass() {
     Gson gson = new GsonBuilder().registerTypeAdapter(Base.class, new JsonSerializer<Base> () {
       @Override
@@ -206,6 +222,7 @@ public class CustomTypeAdaptersTest extends TestCase {
     }
   }
 
+  @Test
   public void testCustomSerializerInvokedForPrimitives() {
     Gson gson = new GsonBuilder()
         .registerTypeAdapter(boolean.class, new JsonSerializer<Boolean>() {
@@ -218,6 +235,7 @@ public class CustomTypeAdaptersTest extends TestCase {
     assertEquals("true", gson.toJson(true, Boolean.class));
   }
 
+  @Test
   public void testCustomDeserializerInvokedForPrimitives() {
     Gson gson = new GsonBuilder()
         .registerTypeAdapter(boolean.class, new JsonDeserializer<Boolean>() {
@@ -231,6 +249,7 @@ public class CustomTypeAdaptersTest extends TestCase {
     assertEquals(Boolean.TRUE, gson.fromJson("true", Boolean.class));
   }
 
+  @Test
   public void testCustomByteArraySerializer() {
     Gson gson = new GsonBuilder().registerTypeAdapter(byte[].class, new JsonSerializer<byte[]>() {
       @Override
@@ -247,6 +266,7 @@ public class CustomTypeAdaptersTest extends TestCase {
     assertEquals("\"0123456789\"", json);
   }
 
+  @Test
   public void testCustomByteArrayDeserializerAndInstanceCreator() {
     GsonBuilder gsonBuilder = new GsonBuilder().registerTypeAdapter(byte[].class,
         new JsonDeserializer<byte[]>() {
@@ -305,6 +325,7 @@ public class CustomTypeAdaptersTest extends TestCase {
   }
 
   // Test created from Issue 70
+  @Test
   public void testCustomAdapterInvokedForCollectionElementSerializationWithType() {
     Gson gson = new GsonBuilder()
       .registerTypeAdapter(StringHolder.class, new StringHolderTypeAdapter())
@@ -318,6 +339,7 @@ public class CustomTypeAdaptersTest extends TestCase {
   }
 
   // Test created from Issue 70
+  @Test
   public void testCustomAdapterInvokedForCollectionElementSerialization() {
     Gson gson = new GsonBuilder()
       .registerTypeAdapter(StringHolder.class, new StringHolderTypeAdapter())
@@ -330,6 +352,7 @@ public class CustomTypeAdaptersTest extends TestCase {
   }
 
   // Test created from Issue 70
+  @Test
   public void testCustomAdapterInvokedForCollectionElementDeserialization() {
     Gson gson = new GsonBuilder()
       .registerTypeAdapter(StringHolder.class, new StringHolderTypeAdapter())
@@ -343,6 +366,7 @@ public class CustomTypeAdaptersTest extends TestCase {
   }
 
   // Test created from Issue 70
+  @Test
   public void testCustomAdapterInvokedForMapElementSerializationWithType() {
     Gson gson = new GsonBuilder()
       .registerTypeAdapter(StringHolder.class, new StringHolderTypeAdapter())
@@ -356,6 +380,7 @@ public class CustomTypeAdaptersTest extends TestCase {
   }
 
   // Test created from Issue 70
+  @Test
   public void testCustomAdapterInvokedForMapElementSerialization() {
     Gson gson = new GsonBuilder()
       .registerTypeAdapter(StringHolder.class, new StringHolderTypeAdapter())
@@ -368,6 +393,7 @@ public class CustomTypeAdaptersTest extends TestCase {
   }
 
   // Test created from Issue 70
+  @Test
   public void testCustomAdapterInvokedForMapElementDeserialization() {
     Gson gson = new GsonBuilder()
       .registerTypeAdapter(StringHolder.class, new StringHolderTypeAdapter())
@@ -380,6 +406,7 @@ public class CustomTypeAdaptersTest extends TestCase {
     assertEquals("Tomaw", foo.part2);
   }
 
+  @Test
   public void testEnsureCustomSerializerNotInvokedForNullValues() {
     Gson gson = new GsonBuilder()
         .registerTypeAdapter(DataHolder.class, new DataHolderSerializer())
@@ -389,6 +416,7 @@ public class CustomTypeAdaptersTest extends TestCase {
     assertEquals("{\"wrappedData\":{\"myData\":\"abc\"}}", json);
   }
 
+  @Test
   public void testEnsureCustomDeserializerNotInvokedForNullValues() {
     Gson gson = new GsonBuilder()
             .setLenient()
@@ -400,6 +428,7 @@ public class CustomTypeAdaptersTest extends TestCase {
   }
 
   // Test created from Issue 352
+  @Test
   public void testRegisterHierarchyAdapterForDate() {
     Gson gson = new GsonBuilder()
             .registerTypeHierarchyAdapter(Date.class, new DateTypeAdapter())
diff --git a/gson/src/test/java/com/google/gson/functional/DefaultTypeAdaptersTest.java b/gson/src/test/java/com/google/gson/functional/DefaultTypeAdaptersTest.java
index 61f1a95d..76903ad6 100644
--- a/gson/src/test/java/com/google/gson/functional/DefaultTypeAdaptersTest.java
+++ b/gson/src/test/java/com/google/gson/functional/DefaultTypeAdaptersTest.java
@@ -15,6 +15,11 @@
  */
 package com.google.gson.functional;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
 import com.google.gson.JsonArray;
@@ -54,7 +59,9 @@ import java.util.Set;
 import java.util.TimeZone;
 import java.util.TreeSet;
 import java.util.UUID;
-import junit.framework.TestCase;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
 
 /**
  * Functional test for Json serialization and deserialization for common classes for which default
@@ -63,14 +70,13 @@ import junit.framework.TestCase;
  * @author Inderjeet Singh
  * @author Joel Leitch
  */
-public class DefaultTypeAdaptersTest extends TestCase {
+public class DefaultTypeAdaptersTest {
   private Gson gson;
   private TimeZone oldTimeZone;
   private Locale oldLocale;
 
-  @Override
-  protected void setUp() throws Exception {
-    super.setUp();
+  @Before
+  public void setUp() throws Exception {
     this.oldTimeZone = TimeZone.getDefault();
     TimeZone.setDefault(TimeZone.getTimeZone("America/Los_Angeles"));
     this.oldLocale = Locale.getDefault();
@@ -78,13 +84,13 @@ public class DefaultTypeAdaptersTest extends TestCase {
     gson = new Gson();
   }
 
-  @Override
-  protected void tearDown() throws Exception {
+  @After
+  public void tearDown() throws Exception {
     TimeZone.setDefault(oldTimeZone);
     Locale.setDefault(oldLocale);
-    super.tearDown();
   }
 
+  @Test
   public void testClassSerialization() {
     try {
       gson.toJson(String.class);
@@ -96,6 +102,7 @@ public class DefaultTypeAdaptersTest extends TestCase {
     assertEquals("\"java.lang.String\"", gson.toJson(String.class));
   }
 
+  @Test
   public void testClassDeserialization() {
     try {
       gson.fromJson("String.class", String.class.getClass());
@@ -107,12 +114,14 @@ public class DefaultTypeAdaptersTest extends TestCase {
     assertEquals(String.class, gson.fromJson("java.lang.String", Class.class));
   }
 
+  @Test
   public void testUrlSerialization() throws Exception {
     String urlValue = "http://google.com/";
     URL url = new URL(urlValue);
     assertEquals("\"http://google.com/\"", gson.toJson(url));
   }
 
+  @Test
   public void testUrlDeserialization() {
     String urlValue = "http://google.com/";
     String json = "'http:\\/\\/google.com\\/'";
@@ -123,11 +132,13 @@ public class DefaultTypeAdaptersTest extends TestCase {
     assertEquals(urlValue, target.toExternalForm());
   }
 
+  @Test
   public void testUrlNullSerialization() throws Exception {
     ClassWithUrlField target = new ClassWithUrlField();
     assertEquals("{}", gson.toJson(target));
   }
 
+  @Test
   public void testUrlNullDeserialization() {
     String json = "{}";
     ClassWithUrlField target = gson.fromJson(json, ClassWithUrlField.class);
@@ -138,12 +149,14 @@ public class DefaultTypeAdaptersTest extends TestCase {
     URL url;
   }
 
+  @Test
   public void testUriSerialization() throws Exception {
     String uriValue = "http://google.com/";
     URI uri = new URI(uriValue);
     assertEquals("\"http://google.com/\"", gson.toJson(uri));
   }
 
+  @Test
   public void testUriDeserialization() {
     String uriValue = "http://google.com/";
     String json = '"' + uriValue + '"';
@@ -151,6 +164,7 @@ public class DefaultTypeAdaptersTest extends TestCase {
     assertEquals(uriValue, target.toASCIIString());
   }
 
+  @Test
   public void testNullSerialization() throws Exception {
     testNullSerializationAndDeserialization(Boolean.class);
     testNullSerializationAndDeserialization(Byte.class);
@@ -191,12 +205,14 @@ public class DefaultTypeAdaptersTest extends TestCase {
     assertEquals(null, gson.fromJson("null", c));
   }
 
+  @Test
   public void testUuidSerialization() throws Exception {
     String uuidValue = "c237bec1-19ef-4858-a98e-521cf0aad4c0";
     UUID uuid = UUID.fromString(uuidValue);
     assertEquals('"' + uuidValue + '"', gson.toJson(uuid));
   }
 
+  @Test
   public void testUuidDeserialization() {
     String uuidValue = "c237bec1-19ef-4858-a98e-521cf0aad4c0";
     String json = '"' + uuidValue + '"';
@@ -204,34 +220,40 @@ public class DefaultTypeAdaptersTest extends TestCase {
     assertEquals(uuidValue, target.toString());
   }
 
+  @Test
   public void testLocaleSerializationWithLanguage() {
     Locale target = new Locale("en");
     assertEquals("\"en\"", gson.toJson(target));
   }
 
+  @Test
   public void testLocaleDeserializationWithLanguage() {
     String json = "\"en\"";
     Locale locale = gson.fromJson(json, Locale.class);
     assertEquals("en", locale.getLanguage());
   }
 
+  @Test
   public void testLocaleSerializationWithLanguageCountry() {
     Locale target = Locale.CANADA_FRENCH;
     assertEquals("\"fr_CA\"", gson.toJson(target));
   }
 
+  @Test
   public void testLocaleDeserializationWithLanguageCountry() {
     String json = "\"fr_CA\"";
     Locale locale = gson.fromJson(json, Locale.class);
     assertEquals(Locale.CANADA_FRENCH, locale);
   }
 
+  @Test
   public void testLocaleSerializationWithLanguageCountryVariant() {
     Locale target = new Locale("de", "DE", "EURO");
     String json = gson.toJson(target);
     assertEquals("\"de_DE_EURO\"", json);
   }
 
+  @Test
   public void testLocaleDeserializationWithLanguageCountryVariant() {
     String json = "\"de_DE_EURO\"";
     Locale locale = gson.fromJson(json, Locale.class);
@@ -240,6 +262,7 @@ public class DefaultTypeAdaptersTest extends TestCase {
     assertEquals("EURO", locale.getVariant());
   }
 
+  @Test
   public void testBigDecimalFieldSerialization() {
     ClassWithBigDecimal target = new ClassWithBigDecimal("-122.01e-21");
     String json = gson.toJson(target);
@@ -247,6 +270,7 @@ public class DefaultTypeAdaptersTest extends TestCase {
     assertEquals(target.value, new BigDecimal(actual));
   }
 
+  @Test
   public void testBigDecimalFieldDeserialization() {
     ClassWithBigDecimal expected = new ClassWithBigDecimal("-122.01e-21");
     String json = expected.getExpectedJson();
@@ -254,6 +278,7 @@ public class DefaultTypeAdaptersTest extends TestCase {
     assertEquals(expected.value, actual.value);
   }
 
+  @Test
   public void testBadValueForBigDecimalDeserialization() {
     try {
       gson.fromJson("{\"value\"=1.5e-1.0031}", ClassWithBigDecimal.class);
@@ -261,12 +286,14 @@ public class DefaultTypeAdaptersTest extends TestCase {
     } catch (JsonParseException expected) { }
   }
 
+  @Test
   public void testBigIntegerFieldSerialization() {
     ClassWithBigInteger target = new ClassWithBigInteger("23232323215323234234324324324324324324");
     String json = gson.toJson(target);
     assertEquals(target.getExpectedJson(), json);
   }
 
+  @Test
   public void testBigIntegerFieldDeserialization() {
     ClassWithBigInteger expected = new ClassWithBigInteger("879697697697697697697697697697697697");
     String json = expected.getExpectedJson();
@@ -274,6 +301,7 @@ public class DefaultTypeAdaptersTest extends TestCase {
     assertEquals(expected.value, actual.value);
   }
 
+  @Test
   public void testOverrideBigIntegerTypeAdapter() throws Exception {
     gson = new GsonBuilder()
         .registerTypeAdapter(BigInteger.class, new NumberAsStringAdapter(BigInteger.class))
@@ -282,6 +310,7 @@ public class DefaultTypeAdaptersTest extends TestCase {
     assertEquals(new BigInteger("123"), gson.fromJson("\"123\"", BigInteger.class));
   }
 
+  @Test
   public void testOverrideBigDecimalTypeAdapter() throws Exception {
     gson = new GsonBuilder()
         .registerTypeAdapter(BigDecimal.class, new NumberAsStringAdapter(BigDecimal.class))
@@ -290,6 +319,7 @@ public class DefaultTypeAdaptersTest extends TestCase {
     assertEquals(new BigDecimal("1.1"), gson.fromJson("\"1.1\"", BigDecimal.class));
   }
 
+  @Test
   public void testSetSerialization() throws Exception {
     Gson gson = new Gson();
     HashSet<String> s = new HashSet<>();
@@ -301,6 +331,7 @@ public class DefaultTypeAdaptersTest extends TestCase {
     assertEquals("[\"blah\"]", json);
   }
 
+  @Test
   public void testBitSetSerialization() throws Exception {
     Gson gson = new Gson();
     BitSet bits = new BitSet();
@@ -311,6 +342,7 @@ public class DefaultTypeAdaptersTest extends TestCase {
     assertEquals("[0,1,0,1,1,1,0,0,0,1]", json);
   }
 
+  @Test
   public void testBitSetDeserialization() throws Exception {
     BitSet expected = new BitSet();
     expected.set(0);
@@ -345,6 +377,7 @@ public class DefaultTypeAdaptersTest extends TestCase {
     }
   }
 
+  @Test
   public void testDefaultDateSerialization() {
     Date now = new Date(1315806903103L);
     String json = gson.toJson(now);
@@ -355,6 +388,7 @@ public class DefaultTypeAdaptersTest extends TestCase {
     }
   }
 
+  @Test
   public void testDefaultDateDeserialization() {
     String json = "'Dec 13, 2009 07:18:02 AM'";
     Date extracted = gson.fromJson(json, Date.class);
@@ -378,6 +412,7 @@ public class DefaultTypeAdaptersTest extends TestCase {
     assertEquals(seconds, date.getSeconds());
   }
 
+  @Test
   public void testDefaultDateSerializationUsingBuilder() throws Exception {
     Gson gson = new GsonBuilder().create();
     Date now = new Date(1315806903103L);
@@ -389,6 +424,7 @@ public class DefaultTypeAdaptersTest extends TestCase {
     }
   }
 
+  @Test
   public void testDefaultDateDeserializationUsingBuilder() throws Exception {
     Gson gson = new GsonBuilder().create();
     Date now = new Date(1315806903103L);
@@ -397,6 +433,7 @@ public class DefaultTypeAdaptersTest extends TestCase {
     assertEquals(now.toString(), extracted.toString());
   }
 
+  @Test
   public void testDefaultCalendarSerialization() throws Exception {
     Gson gson = new GsonBuilder().create();
     String json = gson.toJson(Calendar.getInstance());
@@ -408,6 +445,7 @@ public class DefaultTypeAdaptersTest extends TestCase {
     assertTrue(json.contains("second"));
   }
 
+  @Test
   public void testDefaultCalendarDeserialization() throws Exception {
     Gson gson = new Gson();
     String json = "{year:2009,month:2,dayOfMonth:11,hourOfDay:14,minute:29,second:23}";
@@ -420,6 +458,7 @@ public class DefaultTypeAdaptersTest extends TestCase {
     assertEquals(23, cal.get(Calendar.SECOND));
   }
 
+  @Test
   public void testDefaultGregorianCalendarSerialization() throws Exception {
     Gson gson = new GsonBuilder().create();
     GregorianCalendar cal = new GregorianCalendar();
@@ -432,6 +471,7 @@ public class DefaultTypeAdaptersTest extends TestCase {
     assertTrue(json.contains("second"));
   }
 
+  @Test
   public void testDefaultGregorianCalendarDeserialization() throws Exception {
     Gson gson = new Gson();
     String json = "{year:2009,month:2,dayOfMonth:11,hourOfDay:14,minute:29,second:23}";
@@ -444,6 +484,7 @@ public class DefaultTypeAdaptersTest extends TestCase {
     assertEquals(23, cal.get(Calendar.SECOND));
   }
 
+  @Test
   public void testDateSerializationWithPattern() throws Exception {
     String pattern = "yyyy-MM-dd";
     Gson gson = new GsonBuilder().setDateFormat(DateFormat.FULL).setDateFormat(pattern).create();
@@ -453,6 +494,7 @@ public class DefaultTypeAdaptersTest extends TestCase {
   }
 
   @SuppressWarnings("deprecation")
+  @Test
   public void testDateDeserializationWithPattern() throws Exception {
     String pattern = "yyyy-MM-dd";
     Gson gson = new GsonBuilder().setDateFormat(DateFormat.FULL).setDateFormat(pattern).create();
@@ -464,6 +506,7 @@ public class DefaultTypeAdaptersTest extends TestCase {
     assertEquals(now.getDay(), extracted.getDay());
   }
 
+  @Test
   public void testDateSerializationWithPatternNotOverridenByTypeAdapter() throws Exception {
     String pattern = "yyyy-MM-dd";
     Gson gson = new GsonBuilder()
@@ -483,6 +526,7 @@ public class DefaultTypeAdaptersTest extends TestCase {
   }
 
   // http://code.google.com/p/google-gson/issues/detail?id=230
+  @Test
   public void testDateSerializationInCollection() throws Exception {
     Type listOfDates = new TypeToken<List<Date>>() {}.getType();
     TimeZone defaultTimeZone = TimeZone.getDefault();
@@ -501,6 +545,7 @@ public class DefaultTypeAdaptersTest extends TestCase {
     }
   }
 
+  @Test
   public void testJsonPrimitiveSerialization() {
     assertEquals("5", gson.toJson(new JsonPrimitive(5), JsonElement.class));
     assertEquals("true", gson.toJson(new JsonPrimitive(true), JsonElement.class));
@@ -508,6 +553,7 @@ public class DefaultTypeAdaptersTest extends TestCase {
     assertEquals("\"a\"", gson.toJson(new JsonPrimitive('a'), JsonElement.class));
   }
 
+  @Test
   public void testJsonPrimitiveDeserialization() {
     assertEquals(new JsonPrimitive(5), gson.fromJson("5", JsonElement.class));
     assertEquals(new JsonPrimitive(5), gson.fromJson("5", JsonPrimitive.class));
@@ -519,16 +565,19 @@ public class DefaultTypeAdaptersTest extends TestCase {
     assertEquals(new JsonPrimitive('a'), gson.fromJson("\"a\"", JsonPrimitive.class));
   }
 
+  @Test
   public void testJsonNullSerialization() {
     assertEquals("null", gson.toJson(JsonNull.INSTANCE, JsonElement.class));
     assertEquals("null", gson.toJson(JsonNull.INSTANCE, JsonNull.class));
   }
 
+  @Test
   public void testNullJsonElementSerialization() {
     assertEquals("null", gson.toJson(null, JsonElement.class));
     assertEquals("null", gson.toJson(null, JsonNull.class));
   }
 
+  @Test
   public void testJsonArraySerialization() {
     JsonArray array = new JsonArray();
     array.add(new JsonPrimitive(1));
@@ -537,6 +586,7 @@ public class DefaultTypeAdaptersTest extends TestCase {
     assertEquals("[1,2,3]", gson.toJson(array, JsonElement.class));
   }
 
+  @Test
   public void testJsonArrayDeserialization() {
     JsonArray array = new JsonArray();
     array.add(new JsonPrimitive(1));
@@ -548,6 +598,7 @@ public class DefaultTypeAdaptersTest extends TestCase {
     assertEquals(array, gson.fromJson(json, JsonArray.class));
   }
 
+  @Test
   public void testJsonObjectSerialization() {
     JsonObject object = new JsonObject();
     object.add("foo", new JsonPrimitive(1));
@@ -555,6 +606,7 @@ public class DefaultTypeAdaptersTest extends TestCase {
     assertEquals("{\"foo\":1,\"bar\":2}", gson.toJson(object, JsonElement.class));
   }
 
+  @Test
   public void testJsonObjectDeserialization() {
     JsonObject object = new JsonObject();
     object.add("foo", new JsonPrimitive(1));
@@ -568,11 +620,13 @@ public class DefaultTypeAdaptersTest extends TestCase {
     assertEquals(object, actualObj);
   }
 
+  @Test
   public void testJsonNullDeserialization() {
     assertEquals(JsonNull.INSTANCE, gson.fromJson("null", JsonElement.class));
     assertEquals(JsonNull.INSTANCE, gson.fromJson("null", JsonNull.class));
   }
 
+  @Test
   public void testJsonElementTypeMismatch() {
     try {
       gson.fromJson("\"abc\"", JsonObject.class);
@@ -603,6 +657,7 @@ public class DefaultTypeAdaptersTest extends TestCase {
     }
   }
 
+  @Test
   public void testPropertiesSerialization() {
     Properties props = new Properties();
     props.setProperty("foo", "bar");
@@ -611,12 +666,14 @@ public class DefaultTypeAdaptersTest extends TestCase {
     assertEquals(expected, json);
   }
 
+  @Test
   public void testPropertiesDeserialization() {
     String json = "{foo:'bar'}";
     Properties props = gson.fromJson(json, Properties.class);
     assertEquals("bar", props.getProperty("foo"));
   }
 
+  @Test
   public void testTreeSetSerialization() {
     TreeSet<String> treeSet = new TreeSet<>();
     treeSet.add("Value1");
@@ -624,6 +681,7 @@ public class DefaultTypeAdaptersTest extends TestCase {
     assertEquals("[\"Value1\"]", json);
   }
 
+  @Test
   public void testTreeSetDeserialization() {
     String json = "['Value1']";
     Type type = new TypeToken<TreeSet<String>>() {}.getType();
@@ -631,23 +689,27 @@ public class DefaultTypeAdaptersTest extends TestCase {
     assertTrue(treeSet.contains("Value1"));
   }
 
+  @Test
   public void testStringBuilderSerialization() {
     StringBuilder sb = new StringBuilder("abc");
     String json = gson.toJson(sb);
     assertEquals("\"abc\"", json);
   }
 
+  @Test
   public void testStringBuilderDeserialization() {
     StringBuilder sb = gson.fromJson("'abc'", StringBuilder.class);
     assertEquals("abc", sb.toString());
   }
 
+  @Test
   public void testStringBufferSerialization() {
     StringBuffer sb = new StringBuffer("abc");
     String json = gson.toJson(sb);
     assertEquals("\"abc\"", json);
   }
 
+  @Test
   public void testStringBufferDeserialization() {
     StringBuffer sb = gson.fromJson("'abc'", StringBuffer.class);
     assertEquals("abc", sb.toString());
diff --git a/gson/src/test/java/com/google/gson/functional/DelegateTypeAdapterTest.java b/gson/src/test/java/com/google/gson/functional/DelegateTypeAdapterTest.java
index 87ee81e5..68e7c363 100644
--- a/gson/src/test/java/com/google/gson/functional/DelegateTypeAdapterTest.java
+++ b/gson/src/test/java/com/google/gson/functional/DelegateTypeAdapterTest.java
@@ -15,11 +15,7 @@
  */
 package com.google.gson.functional;
 
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.List;
-
-import junit.framework.TestCase;
+import static org.junit.Assert.assertEquals;
 
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
@@ -29,26 +25,31 @@ import com.google.gson.common.TestTypes.BagOfPrimitives;
 import com.google.gson.reflect.TypeToken;
 import com.google.gson.stream.JsonReader;
 import com.google.gson.stream.JsonWriter;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.Before;
+import org.junit.Test;
 
 /**
  * Functional tests for {@link Gson#getDelegateAdapter(TypeAdapterFactory, TypeToken)} method.
  *
  * @author Inderjeet Singh
  */
-public class DelegateTypeAdapterTest extends TestCase {
+public class DelegateTypeAdapterTest {
 
   private StatsTypeAdapterFactory stats;
   private Gson gson;
 
-  @Override
-  protected void setUp() throws Exception {
-    super.setUp();
+  @Before
+  public void setUp() throws Exception {
     stats = new StatsTypeAdapterFactory();
     gson = new GsonBuilder()
       .registerTypeAdapterFactory(stats)
       .create();
   }
 
+  @Test
   public void testDelegateInvoked() {
     List<BagOfPrimitives> bags = new ArrayList<>();
     for (int i = 0; i < 10; ++i) {
@@ -61,6 +62,7 @@ public class DelegateTypeAdapterTest extends TestCase {
     assertEquals(51, stats.numWrites);
   }
 
+  @Test
   public void testDelegateInvokedOnStrings() {
     String[] bags = {"1", "2", "3", "4"};
     String json = gson.toJson(bags);
diff --git a/gson/src/test/java/com/google/gson/functional/EnumTest.java b/gson/src/test/java/com/google/gson/functional/EnumTest.java
index b46f80b8..7bb306d0 100644
--- a/gson/src/test/java/com/google/gson/functional/EnumTest.java
+++ b/gson/src/test/java/com/google/gson/functional/EnumTest.java
@@ -16,6 +16,11 @@
 
 package com.google.gson.functional;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
 import com.google.gson.JsonDeserializationContext;
@@ -36,7 +41,8 @@ import java.util.EnumMap;
 import java.util.EnumSet;
 import java.util.Map;
 import java.util.Set;
-import junit.framework.TestCase;
+import org.junit.Before;
+import org.junit.Test;
 
 /**
  * Functional tests for Java 5.0 enums.
@@ -44,26 +50,28 @@ import junit.framework.TestCase;
  * @author Inderjeet Singh
  * @author Joel Leitch
  */
-public class EnumTest extends TestCase {
+public class EnumTest {
 
   private Gson gson;
 
-  @Override
-  protected void setUp() throws Exception {
-    super.setUp();
+  @Before
+  public void setUp() throws Exception {
     gson = new Gson();
   }
 
+  @Test
   public void testTopLevelEnumSerialization() throws Exception {
     String result = gson.toJson(MyEnum.VALUE1);
     assertEquals('"' + MyEnum.VALUE1.toString() + '"', result);
   }
 
+  @Test
   public void testTopLevelEnumDeserialization() throws Exception {
     MyEnum result = gson.fromJson('"' + MyEnum.VALUE1.toString() + '"', MyEnum.class);
     assertEquals(MyEnum.VALUE1, result);
   }
 
+  @Test
   public void testCollectionOfEnumsSerialization() {
     Type type = new TypeToken<Collection<MyEnum>>() {}.getType();
     Collection<MyEnum> target = new ArrayList<>();
@@ -76,6 +84,7 @@ public class EnumTest extends TestCase {
     assertEquals(expectedJson, actualJson);
   }
 
+  @Test
   public void testCollectionOfEnumsDeserialization() {
     Type type = new TypeToken<Collection<MyEnum>>() {}.getType();
     String json = "[\"VALUE1\",\"VALUE2\"]";
@@ -84,11 +93,13 @@ public class EnumTest extends TestCase {
     MoreAsserts.assertContains(target, MyEnum.VALUE2);
   }
 
+  @Test
   public void testClassWithEnumFieldSerialization() throws Exception {
     ClassWithEnumFields target = new ClassWithEnumFields();
     assertEquals(target.getExpectedJson(), gson.toJson(target));
   }
 
+  @Test
   public void testClassWithEnumFieldDeserialization() throws Exception {
     String json = "{value1:'VALUE1',value2:'VALUE2'}";
     ClassWithEnumFields target = gson.fromJson(json, ClassWithEnumFields.class);
@@ -111,6 +122,7 @@ public class EnumTest extends TestCase {
   /**
    * Test for issue 226.
    */
+  @Test
   public void testEnumSubclass() {
     assertFalse(Roshambo.class == Roshambo.ROCK.getClass());
     assertEquals("\"ROCK\"", gson.toJson(Roshambo.ROCK));
@@ -120,6 +132,7 @@ public class EnumTest extends TestCase {
         gson.fromJson("[\"ROCK\",\"PAPER\",\"SCISSORS\"]", new TypeToken<Set<Roshambo>>() {}.getType()));
   }
 
+  @Test
   public void testEnumSubclassWithRegisteredTypeAdapter() {
     gson = new GsonBuilder()
         .registerTypeHierarchyAdapter(Roshambo.class, new MyEnumTypeAdapter())
@@ -132,6 +145,7 @@ public class EnumTest extends TestCase {
         gson.fromJson("[\"123ROCK\",\"123PAPER\",\"123SCISSORS\"]", new TypeToken<Set<Roshambo>>() {}.getType()));
   }
 
+  @Test
   public void testEnumSubclassAsParameterizedType() {
     Collection<Roshambo> list = new ArrayList<>();
     list.add(Roshambo.ROCK);
@@ -146,11 +160,13 @@ public class EnumTest extends TestCase {
     MoreAsserts.assertContains(actualJsonList, Roshambo.PAPER);
   }
 
+  @Test
   public void testEnumCaseMapping() {
     assertEquals(Gender.MALE, gson.fromJson("\"boy\"", Gender.class));
     assertEquals("\"boy\"", gson.toJson(Gender.MALE, Gender.class));
   }
 
+  @Test
   public void testEnumSet() {
     EnumSet<Roshambo> foo = EnumSet.of(Roshambo.ROCK, Roshambo.PAPER);
     String json = gson.toJson(foo);
@@ -163,6 +179,7 @@ public class EnumTest extends TestCase {
     assertFalse(bar.contains(Roshambo.SCISSORS));
   }
 
+  @Test
   public void testEnumMap() throws Exception {
     EnumMap<MyEnum, String> map = new EnumMap<>(MyEnum.class);
     map.put(MyEnum.VALUE1, "test");
@@ -215,6 +232,7 @@ public class EnumTest extends TestCase {
     FEMALE
   }
 
+  @Test
   public void testEnumClassWithFields() {
     assertEquals("\"RED\"", gson.toJson(Color.RED));
     assertEquals("red", gson.fromJson("RED", Color.class).value);
@@ -231,6 +249,7 @@ public class EnumTest extends TestCase {
     }
   }
 
+  @Test
   public void testEnumToStringRead() {
     // Should still be able to read constant name
     assertEquals(CustomToString.A, gson.fromJson("\"A\"", CustomToString.class));
@@ -253,6 +272,7 @@ public class EnumTest extends TestCase {
    * Test that enum constant names have higher precedence than {@code toString()}
    * result.
    */
+  @Test
   public void testEnumToStringReadInterchanged() {
     assertEquals(InterchangedToString.A, gson.fromJson("\"A\"", InterchangedToString.class));
     assertEquals(InterchangedToString.B, gson.fromJson("\"B\"", InterchangedToString.class));
diff --git a/gson/src/test/java/com/google/gson/functional/EscapingTest.java b/gson/src/test/java/com/google/gson/functional/EscapingTest.java
index 053fd9a2..f8c6f4fe 100644
--- a/gson/src/test/java/com/google/gson/functional/EscapingTest.java
+++ b/gson/src/test/java/com/google/gson/functional/EscapingTest.java
@@ -16,12 +16,17 @@
 
 package com.google.gson.functional;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
 import com.google.gson.common.TestTypes.BagOfPrimitives;
 import java.util.ArrayList;
 import java.util.List;
-import junit.framework.TestCase;
+import org.junit.Before;
+import org.junit.Test;
 
 /**
  * Performs some functional test involving JSON output escaping.
@@ -29,15 +34,15 @@ import junit.framework.TestCase;
  * @author Inderjeet Singh
  * @author Joel Leitch
  */
-public class EscapingTest extends TestCase {
+public class EscapingTest {
   private Gson gson;
 
-  @Override
-  protected void setUp() throws Exception {
-    super.setUp();
+  @Before
+  public void setUp() throws Exception {
     gson = new Gson();
   }
 
+  @Test
   public void testEscapingQuotesInStringArray() throws Exception {
     String[] valueWithQuotes = { "beforeQuote\"afterQuote" };
     String jsonRepresentation = gson.toJson(valueWithQuotes);
@@ -46,6 +51,7 @@ public class EscapingTest extends TestCase {
     assertEquals(valueWithQuotes[0], target[0]);
   }
 
+  @Test
   public void testEscapeAllHtmlCharacters() {
     List<String> strings = new ArrayList<>();
     strings.add("<");
@@ -58,6 +64,7 @@ public class EscapingTest extends TestCase {
         gson.toJson(strings));
   }
 
+  @Test
   public void testEscapingObjectFields() throws Exception {
     BagOfPrimitives objWithPrimitives = new BagOfPrimitives(1L, 1, true, "test with\" <script>");
     String jsonRepresentation = gson.toJson(objWithPrimitives);
@@ -69,6 +76,7 @@ public class EscapingTest extends TestCase {
     assertEquals(objWithPrimitives.getExpectedJson(), expectedObject.getExpectedJson());
   }
   
+  @Test
   public void testGsonAcceptsEscapedAndNonEscapedJsonDeserialization() throws Exception {
     Gson escapeHtmlGson = new GsonBuilder().create();
     Gson noEscapeHtmlGson = new GsonBuilder().disableHtmlEscaping().create();
@@ -82,6 +90,7 @@ public class EscapingTest extends TestCase {
     assertEquals(target, escapeHtmlGson.fromJson(nonEscapedJsonForm, BagOfPrimitives.class));
   }
 
+  @Test
   public void testGsonDoubleDeserialization() {
     BagOfPrimitives expected = new BagOfPrimitives(3L, 4, true, "value1");
     String json = gson.toJson(gson.toJson(expected));
diff --git a/gson/src/test/java/com/google/gson/functional/ExclusionStrategyFunctionalTest.java b/gson/src/test/java/com/google/gson/functional/ExclusionStrategyFunctionalTest.java
index 2eca8bb4..4091d26d 100644
--- a/gson/src/test/java/com/google/gson/functional/ExclusionStrategyFunctionalTest.java
+++ b/gson/src/test/java/com/google/gson/functional/ExclusionStrategyFunctionalTest.java
@@ -16,6 +16,11 @@
 
 package com.google.gson.functional;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
 import com.google.gson.ExclusionStrategy;
 import com.google.gson.FieldAttributes;
 import com.google.gson.Gson;
@@ -26,7 +31,8 @@ import java.lang.annotation.ElementType;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
-import junit.framework.TestCase;
+import org.junit.Before;
+import org.junit.Test;
 
 /**
  * Performs some functional tests when Gson is instantiated with some common user defined
@@ -35,7 +41,7 @@ import junit.framework.TestCase;
  * @author Inderjeet Singh
  * @author Joel Leitch
  */
-public class ExclusionStrategyFunctionalTest extends TestCase {
+public class ExclusionStrategyFunctionalTest {
   private static final ExclusionStrategy EXCLUDE_SAMPLE_OBJECT_FOR_TEST = new ExclusionStrategy() {
     @Override public boolean shouldSkipField(FieldAttributes f) {
       return false;
@@ -47,12 +53,12 @@ public class ExclusionStrategyFunctionalTest extends TestCase {
 
   private SampleObjectForTest src;
 
-  @Override
-  protected void setUp() throws Exception {
-    super.setUp();
+  @Before
+  public void setUp() throws Exception {
     src = new SampleObjectForTest();
   }
 
+  @Test
   public void testExclusionStrategySerialization() throws Exception {
     Gson gson = createGson(new MyExclusionStrategy(String.class), true);
     String json = gson.toJson(src);
@@ -61,6 +67,7 @@ public class ExclusionStrategyFunctionalTest extends TestCase {
     assertTrue(json.contains("\"longField\""));
   }
 
+  @Test
   public void testExclusionStrategySerializationDoesNotImpactDeserialization() {
     String json = "{\"annotatedField\":1,\"stringField\":\"x\",\"longField\":2}";
     Gson gson = createGson(new MyExclusionStrategy(String.class), true);
@@ -70,6 +77,7 @@ public class ExclusionStrategyFunctionalTest extends TestCase {
     assertEquals(2, value.longField);
   }
 
+  @Test
   public void testExclusionStrategyDeserialization() throws Exception {
     Gson gson = createGson(new MyExclusionStrategy(String.class), false);
     JsonObject json = new JsonObject();
@@ -85,6 +93,7 @@ public class ExclusionStrategyFunctionalTest extends TestCase {
     assertEquals(src.stringField, target.stringField);
   }
 
+  @Test
   public void testExclusionStrategySerializationDoesNotImpactSerialization() throws Exception {
     Gson gson = createGson(new MyExclusionStrategy(String.class), false);
     String json = gson.toJson(src);
@@ -93,6 +102,7 @@ public class ExclusionStrategyFunctionalTest extends TestCase {
     assertTrue(json.contains("\"longField\""));
   }
 
+  @Test
   public void testExclusionStrategyWithMode() throws Exception {
     SampleObjectForTest testObj = new SampleObjectForTest(
         src.annotatedField + 5, src.stringField + "blah,blah",
@@ -112,6 +122,7 @@ public class ExclusionStrategyFunctionalTest extends TestCase {
     assertEquals(src.stringField, target.stringField);
   }
 
+  @Test
   public void testExcludeTopLevelClassSerialization() {
     Gson gson = new GsonBuilder()
         .addSerializationExclusionStrategy(EXCLUDE_SAMPLE_OBJECT_FOR_TEST)
@@ -119,6 +130,7 @@ public class ExclusionStrategyFunctionalTest extends TestCase {
     assertEquals("null", gson.toJson(new SampleObjectForTest(), SampleObjectForTest.class));
   }
 
+  @Test
   public void testExcludeTopLevelClassSerializationDoesNotImpactDeserialization() {
     Gson gson = new GsonBuilder()
         .addSerializationExclusionStrategy(EXCLUDE_SAMPLE_OBJECT_FOR_TEST)
@@ -130,6 +142,7 @@ public class ExclusionStrategyFunctionalTest extends TestCase {
     assertEquals(2, value.longField);
   }
 
+  @Test
   public void testExcludeTopLevelClassDeserialization() {
     Gson gson = new GsonBuilder()
         .addDeserializationExclusionStrategy(EXCLUDE_SAMPLE_OBJECT_FOR_TEST)
@@ -139,6 +152,7 @@ public class ExclusionStrategyFunctionalTest extends TestCase {
     assertNull(value);
   }
 
+  @Test
   public void testExcludeTopLevelClassDeserializationDoesNotImpactSerialization() {
     Gson gson = new GsonBuilder()
         .addDeserializationExclusionStrategy(EXCLUDE_SAMPLE_OBJECT_FOR_TEST)
diff --git a/gson/src/test/java/com/google/gson/functional/ExposeFieldsTest.java b/gson/src/test/java/com/google/gson/functional/ExposeFieldsTest.java
index dd233625..c9645f64 100644
--- a/gson/src/test/java/com/google/gson/functional/ExposeFieldsTest.java
+++ b/gson/src/test/java/com/google/gson/functional/ExposeFieldsTest.java
@@ -16,27 +16,30 @@
 
 package com.google.gson.functional;
 
-import java.lang.reflect.Type;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
 
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
 import com.google.gson.InstanceCreator;
 import com.google.gson.annotations.Expose;
-
-import junit.framework.TestCase;
+import java.lang.reflect.Type;
+import org.junit.Before;
+import org.junit.Test;
 
 /**
  * Unit tests for the regarding functional "@Expose" type tests.
  *
  * @author Joel Leitch
  */
-public class ExposeFieldsTest extends TestCase {
+public class ExposeFieldsTest {
 
   private Gson gson;
 
-  @Override
-  protected void setUp() throws Exception {
-    super.setUp();
+  @Before
+  public void setUp() throws Exception {
     gson = new GsonBuilder()
         .setLenient()
         .excludeFieldsWithoutExposeAnnotation()
@@ -44,6 +47,7 @@ public class ExposeFieldsTest extends TestCase {
         .create();
   }
 
+  @Test
   public void testNullExposeFieldSerialization() throws Exception {
     ClassWithExposedFields object = new ClassWithExposedFields(null, 1);
     String json = gson.toJson(object);
@@ -51,6 +55,7 @@ public class ExposeFieldsTest extends TestCase {
     assertEquals(object.getExpectedJson(), json);
   }
 
+  @Test
   public void testArrayWithOneNullExposeFieldObjectSerialization() throws Exception {
     ClassWithExposedFields object1 = new ClassWithExposedFields(1, 1);
     ClassWithExposedFields object2 = new ClassWithExposedFields(null, 1);
@@ -67,11 +72,13 @@ public class ExposeFieldsTest extends TestCase {
     assertEquals(expected, json);
   }
 
+  @Test
   public void testExposeAnnotationSerialization() throws Exception {
     ClassWithExposedFields target = new ClassWithExposedFields(1, 2);
     assertEquals(target.getExpectedJson(), gson.toJson(target));
   }
 
+  @Test
   public void testExposeAnnotationDeserialization() throws Exception {
     String json = "{a:3,b:4,d:20.0}";
     ClassWithExposedFields target = gson.fromJson(json, ClassWithExposedFields.class);
@@ -81,6 +88,7 @@ public class ExposeFieldsTest extends TestCase {
     assertFalse(target.d == 20);
   }
 
+  @Test
   public void testNoExposedFieldSerialization() throws Exception {
     ClassWithNoExposedFields obj = new ClassWithNoExposedFields();
     String json = gson.toJson(obj);
@@ -88,6 +96,7 @@ public class ExposeFieldsTest extends TestCase {
     assertEquals("{}", json);
   }
 
+  @Test
   public void testNoExposedFieldDeserialization() throws Exception {
     String json = "{a:4,b:5}";
     ClassWithNoExposedFields obj = gson.fromJson(json, ClassWithNoExposedFields.class);
@@ -96,6 +105,7 @@ public class ExposeFieldsTest extends TestCase {
     assertEquals(1, obj.b);
   }
   
+  @Test
   public void testExposedInterfaceFieldSerialization() throws Exception {
     String expected = "{\"interfaceField\":{}}";
     ClassWithInterfaceField target = new ClassWithInterfaceField(new SomeObject());
@@ -104,6 +114,7 @@ public class ExposeFieldsTest extends TestCase {
     assertEquals(expected, actual);
   }
   
+  @Test
   public void testExposedInterfaceFieldDeserialization() throws Exception {
     String json = "{\"interfaceField\":{}}";
     ClassWithInterfaceField obj = gson.fromJson(json, ClassWithInterfaceField.class);
diff --git a/gson/src/test/java/com/google/gson/functional/FieldExclusionTest.java b/gson/src/test/java/com/google/gson/functional/FieldExclusionTest.java
index 080a8234..1411b9f7 100644
--- a/gson/src/test/java/com/google/gson/functional/FieldExclusionTest.java
+++ b/gson/src/test/java/com/google/gson/functional/FieldExclusionTest.java
@@ -16,10 +16,12 @@
 
 package com.google.gson.functional;
 
+import static org.junit.Assert.assertEquals;
+
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
-
-import junit.framework.TestCase;
+import org.junit.Before;
+import org.junit.Test;
 
 /**
  * Performs some functional testing to ensure GSON infrastructure properly serializes/deserializes
@@ -28,17 +30,17 @@ import junit.framework.TestCase;
  *
  * @author Joel Leitch
  */
-public class FieldExclusionTest extends TestCase {
+public class FieldExclusionTest {
   private static final String VALUE = "blah_1234";
 
   private Outer outer;
 
-  @Override
-  protected void setUp() throws Exception {
-    super.setUp();
+  @Before
+  public void setUp() throws Exception {
     outer = new Outer();
   }
 
+  @Test
   public void testDefaultInnerClassExclusion() throws Exception {
     Gson gson = new Gson();
     Outer.Inner target = outer.new Inner(VALUE);
@@ -51,6 +53,7 @@ public class FieldExclusionTest extends TestCase {
     assertEquals(target.toJson(), result);
   }
 
+  @Test
   public void testInnerClassExclusion() throws Exception {
     Gson gson = new GsonBuilder().disableInnerClassSerialization().create();
     Outer.Inner target = outer.new Inner(VALUE);
@@ -58,6 +61,7 @@ public class FieldExclusionTest extends TestCase {
     assertEquals("null", result);
   }
 
+  @Test
   public void testDefaultNestedStaticClassIncluded() throws Exception {
     Gson gson = new Gson();
     Outer.Inner target = outer.new Inner(VALUE);
diff --git a/gson/src/test/java/com/google/gson/functional/FieldNamingTest.java b/gson/src/test/java/com/google/gson/functional/FieldNamingTest.java
index 04ba7b7c..3da98964 100644
--- a/gson/src/test/java/com/google/gson/functional/FieldNamingTest.java
+++ b/gson/src/test/java/com/google/gson/functional/FieldNamingTest.java
@@ -22,14 +22,16 @@ import static com.google.gson.FieldNamingPolicy.LOWER_CASE_WITH_UNDERSCORES;
 import static com.google.gson.FieldNamingPolicy.UPPER_CAMEL_CASE;
 import static com.google.gson.FieldNamingPolicy.UPPER_CAMEL_CASE_WITH_SPACES;
 import static com.google.gson.FieldNamingPolicy.UPPER_CASE_WITH_UNDERSCORES;
+import static org.junit.Assert.assertEquals;
 
 import com.google.gson.FieldNamingPolicy;
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
 import com.google.gson.annotations.SerializedName;
-import junit.framework.TestCase;
+import org.junit.Test;
 
-public final class FieldNamingTest extends TestCase {
+public final class FieldNamingTest {
+  @Test
   public void testIdentity() {
     Gson gson = getGsonWithNamingPolicy(IDENTITY);
     assertEquals("{'lowerCamel':1,'UpperCamel':2,'_lowerCamelLeadingUnderscore':3," +
@@ -38,6 +40,7 @@ public final class FieldNamingTest extends TestCase {
         gson.toJson(new TestNames()).replace('\"', '\''));
   }
 
+  @Test
   public void testUpperCamelCase() {
     Gson gson = getGsonWithNamingPolicy(UPPER_CAMEL_CASE);
     assertEquals("{'LowerCamel':1,'UpperCamel':2,'_LowerCamelLeadingUnderscore':3," +
@@ -46,6 +49,7 @@ public final class FieldNamingTest extends TestCase {
         gson.toJson(new TestNames()).replace('\"', '\''));
   }
 
+  @Test
   public void testUpperCamelCaseWithSpaces() {
     Gson gson = getGsonWithNamingPolicy(UPPER_CAMEL_CASE_WITH_SPACES);
     assertEquals("{'Lower Camel':1,'Upper Camel':2,'_Lower Camel Leading Underscore':3," +
@@ -54,6 +58,7 @@ public final class FieldNamingTest extends TestCase {
         gson.toJson(new TestNames()).replace('\"', '\''));
   }
 
+  @Test
   public void testUpperCaseWithUnderscores() {
     Gson gson = getGsonWithNamingPolicy(UPPER_CASE_WITH_UNDERSCORES);
     assertEquals("{'LOWER_CAMEL':1,'UPPER_CAMEL':2,'_LOWER_CAMEL_LEADING_UNDERSCORE':3," +
@@ -62,6 +67,7 @@ public final class FieldNamingTest extends TestCase {
         gson.toJson(new TestNames()).replace('\"', '\''));
   }
 
+  @Test
   public void testLowerCaseWithUnderscores() {
     Gson gson = getGsonWithNamingPolicy(LOWER_CASE_WITH_UNDERSCORES);
     assertEquals("{'lower_camel':1,'upper_camel':2,'_lower_camel_leading_underscore':3," +
@@ -70,6 +76,7 @@ public final class FieldNamingTest extends TestCase {
         gson.toJson(new TestNames()).replace('\"', '\''));
   }
 
+  @Test
   public void testLowerCaseWithDashes() {
     Gson gson = getGsonWithNamingPolicy(LOWER_CASE_WITH_DASHES);
     assertEquals("{'lower-camel':1,'upper-camel':2,'_lower-camel-leading-underscore':3," +
diff --git a/gson/src/test/java/com/google/gson/functional/GsonVersionDiagnosticsTest.java b/gson/src/test/java/com/google/gson/functional/GsonVersionDiagnosticsTest.java
index 0bf647e1..251c8f78 100644
--- a/gson/src/test/java/com/google/gson/functional/GsonVersionDiagnosticsTest.java
+++ b/gson/src/test/java/com/google/gson/functional/GsonVersionDiagnosticsTest.java
@@ -15,26 +15,25 @@
  */
 package com.google.gson.functional;
 
-import java.io.IOException;
-import java.util.regex.Pattern;
-
-import org.junit.Before;
-import org.junit.Test;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
 
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
 import com.google.gson.TypeAdapter;
 import com.google.gson.stream.JsonReader;
 import com.google.gson.stream.JsonWriter;
-
-import junit.framework.TestCase;
+import java.io.IOException;
+import java.util.regex.Pattern;
+import org.junit.Before;
+import org.junit.Test;
 
 /**
  * Functional tests to validate printing of Gson version on AssertionErrors
  *
  * @author Inderjeet Singh
  */
-public class GsonVersionDiagnosticsTest extends TestCase {
+public class GsonVersionDiagnosticsTest {
   // We require a patch number, even if it is .0, consistent with https://semver.org/#spec-item-2.
   private static final Pattern GSON_VERSION_PATTERN =
       Pattern.compile("(\\(GSON \\d\\.\\d+\\.\\d)(?:[-.][A-Z]+)?\\)$");
@@ -42,7 +41,6 @@ public class GsonVersionDiagnosticsTest extends TestCase {
   private Gson gson;
 
   @Before
-  @Override
   public void setUp() {
     gson = new GsonBuilder().registerTypeAdapter(TestType.class, new TypeAdapter<TestType>() {
       @Override public void write(JsonWriter out, TestType value) {
diff --git a/gson/src/test/java/com/google/gson/functional/InheritanceTest.java b/gson/src/test/java/com/google/gson/functional/InheritanceTest.java
index 84de37de..a760cb76 100644
--- a/gson/src/test/java/com/google/gson/functional/InheritanceTest.java
+++ b/gson/src/test/java/com/google/gson/functional/InheritanceTest.java
@@ -15,6 +15,11 @@
  */
 package com.google.gson.functional;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
 import com.google.gson.Gson;
 import com.google.gson.JsonArray;
 import com.google.gson.JsonElement;
@@ -26,9 +31,6 @@ import com.google.gson.common.TestTypes.ClassWithBaseCollectionField;
 import com.google.gson.common.TestTypes.ClassWithBaseField;
 import com.google.gson.common.TestTypes.Nested;
 import com.google.gson.common.TestTypes.Sub;
-
-import junit.framework.TestCase;
-
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.LinkedList;
@@ -37,6 +39,8 @@ import java.util.Queue;
 import java.util.Set;
 import java.util.SortedSet;
 import java.util.TreeSet;
+import org.junit.Before;
+import org.junit.Test;
 
 /**
  * Functional tests for Json serialization and deserialization of classes with 
@@ -45,21 +49,22 @@ import java.util.TreeSet;
  * @author Inderjeet Singh
  * @author Joel Leitch
  */
-public class InheritanceTest extends TestCase {
+public class InheritanceTest {
   private Gson gson;
 
-  @Override
-  protected void setUp() throws Exception {
-    super.setUp();
+  @Before
+  public void setUp() throws Exception {
     gson = new Gson();
   }
 
+  @Test
   public void testSubClassSerialization() throws Exception {
     SubTypeOfNested target = new SubTypeOfNested(new BagOfPrimitives(10, 20, false, "stringValue"),
         new BagOfPrimitives(30, 40, true, "stringValue"));
     assertEquals(target.getExpectedJson(), gson.toJson(target));
   }
 
+  @Test
   public void testSubClassDeserialization() throws Exception {
     String json = "{\"value\":5,\"primitive1\":{\"longValue\":10,\"intValue\":20,"
         + "\"booleanValue\":false,\"stringValue\":\"stringValue\"},\"primitive2\":"
@@ -69,6 +74,7 @@ public class InheritanceTest extends TestCase {
     assertEquals(json, target.getExpectedJson());
   }
 
+  @Test
   public void testClassWithBaseFieldSerialization() {
     ClassWithBaseField sub = new ClassWithBaseField(new Sub());
     JsonObject json = (JsonObject) gson.toJsonTree(sub);
@@ -76,6 +82,7 @@ public class InheritanceTest extends TestCase {
     assertEquals(Sub.SUB_NAME, base.getAsJsonObject().get(Sub.SUB_FIELD_KEY).getAsString());
   }
 
+  @Test
   public void testClassWithBaseArrayFieldSerialization() {
     Base[] baseClasses = new Base[]{ new Sub(), new Sub()};
     ClassWithBaseArrayField sub = new ClassWithBaseArrayField(baseClasses);
@@ -86,6 +93,7 @@ public class InheritanceTest extends TestCase {
     }
   }
 
+  @Test
   public void testClassWithBaseCollectionFieldSerialization() {
     Collection<Base> baseClasses = new ArrayList<>();
     baseClasses.add(new Sub());
@@ -98,18 +106,21 @@ public class InheritanceTest extends TestCase {
     }
   }
 
+  @Test
   public void testBaseSerializedAsSub() {
     Base base = new Sub();
     JsonObject json = gson.toJsonTree(base).getAsJsonObject();
     assertEquals(Sub.SUB_NAME, json.get(Sub.SUB_FIELD_KEY).getAsString());
   }
 
+  @Test
   public void testBaseSerializedAsSubForToJsonMethod() {
     Base base = new Sub();
     String json = gson.toJson(base);
     assertTrue(json.contains(Sub.SUB_NAME));
   }
 
+  @Test
   public void testBaseSerializedAsBaseWhenSpecifiedWithExplicitType() {
     Base base = new Sub();
     JsonObject json = gson.toJsonTree(base, Base.class).getAsJsonObject();
@@ -117,6 +128,7 @@ public class InheritanceTest extends TestCase {
     assertNull(json.get(Sub.SUB_FIELD_KEY));
   }
 
+  @Test
   public void testBaseSerializedAsBaseWhenSpecifiedWithExplicitTypeForToJsonMethod() {
     Base base = new Sub();
     String json = gson.toJson(base, Base.class);
@@ -124,12 +136,14 @@ public class InheritanceTest extends TestCase {
     assertFalse(json.contains(Sub.SUB_FIELD_KEY));
   }
 
+  @Test
   public void testBaseSerializedAsSubWhenSpecifiedWithExplicitType() {
     Base base = new Sub();
     JsonObject json = gson.toJsonTree(base, Sub.class).getAsJsonObject();
     assertEquals(Sub.SUB_NAME, json.get(Sub.SUB_FIELD_KEY).getAsString());
   }
 
+  @Test
   public void testBaseSerializedAsSubWhenSpecifiedWithExplicitTypeForToJsonMethod() {
     Base base = new Sub();
     String json = gson.toJson(base, Sub.class);
@@ -150,6 +164,7 @@ public class InheritanceTest extends TestCase {
     }
   }
 
+  @Test
   public void testSubInterfacesOfCollectionSerialization() throws Exception {
     List<Integer> list = new LinkedList<>();
     list.add(0);
@@ -176,6 +191,7 @@ public class InheritanceTest extends TestCase {
     assertEquals(target.getExpectedJson(), gson.toJson(target));
   }
 
+  @Test
   public void testSubInterfacesOfCollectionDeserialization() throws Exception {
     String json = "{\"list\":[0,1,2,3],\"queue\":[0,1,2,3],\"set\":[0.1,0.2,0.3,0.4],"
         + "\"sortedSet\":[\"a\",\"b\",\"c\",\"d\"]"
diff --git a/gson/src/test/java/com/google/gson/functional/InstanceCreatorTest.java b/gson/src/test/java/com/google/gson/functional/InstanceCreatorTest.java
index 73284f5c..b70a585b 100644
--- a/gson/src/test/java/com/google/gson/functional/InstanceCreatorTest.java
+++ b/gson/src/test/java/com/google/gson/functional/InstanceCreatorTest.java
@@ -16,6 +16,10 @@
 
 package com.google.gson.functional;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
 import com.google.gson.InstanceCreator;
@@ -28,7 +32,7 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.SortedSet;
 import java.util.TreeSet;
-import junit.framework.TestCase;
+import org.junit.Test;
 
 /**
  * Functional Test exercising custom serialization only. When test applies to both
@@ -36,8 +40,9 @@ import junit.framework.TestCase;
  *
  * @author Inderjeet Singh
  */
-public class InstanceCreatorTest extends TestCase {
+public class InstanceCreatorTest {
 
+  @Test
   public void testInstanceCreatorReturnsBaseType() {
     Gson gson = new GsonBuilder()
             .setLenient()
@@ -48,6 +53,7 @@ public class InstanceCreatorTest extends TestCase {
     assertEquals("BaseRevised", base.baseName);
   }
 
+  @Test
   public void testInstanceCreatorReturnsSubTypeForTopLevelObject() {
     Gson gson = new GsonBuilder()
             .setLenient()
@@ -63,6 +69,7 @@ public class InstanceCreatorTest extends TestCase {
     assertEquals(Sub.SUB_NAME, sub.subName);
   }
 
+  @Test
   public void testInstanceCreatorReturnsSubTypeForField() {
     Gson gson = new GsonBuilder()
             .setLenient()
@@ -75,6 +82,7 @@ public class InstanceCreatorTest extends TestCase {
   }
 
   // This regressed in Gson 2.0 and 2.1
+  @Test
   public void testInstanceCreatorForCollectionType() {
     @SuppressWarnings("serial")
     class SubArrayList<T> extends ArrayList<T> {}
@@ -92,6 +100,7 @@ public class InstanceCreatorTest extends TestCase {
   }
 
   @SuppressWarnings("unchecked")
+  @Test
   public void testInstanceCreatorForParametrizedType() throws Exception {
     @SuppressWarnings("serial")
     class SubTreeSet<T> extends TreeSet<T> {}
diff --git a/gson/src/test/java/com/google/gson/functional/InterfaceTest.java b/gson/src/test/java/com/google/gson/functional/InterfaceTest.java
index 6851f1e9..e94885d8 100644
--- a/gson/src/test/java/com/google/gson/functional/InterfaceTest.java
+++ b/gson/src/test/java/com/google/gson/functional/InterfaceTest.java
@@ -16,9 +16,11 @@
 
 package com.google.gson.functional;
 
-import com.google.gson.Gson;
+import static org.junit.Assert.assertEquals;
 
-import junit.framework.TestCase;
+import com.google.gson.Gson;
+import org.junit.Before;
+import org.junit.Test;
 
 /**
  * Functional tests involving interfaces.
@@ -26,23 +28,24 @@ import junit.framework.TestCase;
  * @author Inderjeet Singh
  * @author Joel Leitch
  */
-public class InterfaceTest extends TestCase {
+public class InterfaceTest {
   private static final String OBJ_JSON = "{\"someStringValue\":\"StringValue\"}";
 
   private Gson gson;
   private TestObject obj;
 
-  @Override
-  protected void setUp() throws Exception {
-    super.setUp();
+  @Before
+  public void setUp() throws Exception {
     gson = new Gson();
     obj = new TestObject("StringValue");
   }
 
+  @Test
   public void testSerializingObjectImplementingInterface() throws Exception {
     assertEquals(OBJ_JSON, gson.toJson(obj));
   }
   
+  @Test
   public void testSerializingInterfaceObjectField() throws Exception {
     TestObjectWrapper objWrapper = new TestObjectWrapper(obj);
     assertEquals("{\"obj\":" + OBJ_JSON + "}", gson.toJson(objWrapper));
diff --git a/gson/src/test/java/com/google/gson/functional/InternationalizationTest.java b/gson/src/test/java/com/google/gson/functional/InternationalizationTest.java
index 8d10dee9..2c4bfdc2 100644
--- a/gson/src/test/java/com/google/gson/functional/InternationalizationTest.java
+++ b/gson/src/test/java/com/google/gson/functional/InternationalizationTest.java
@@ -16,23 +16,26 @@
 
 package com.google.gson.functional;
 
+import static org.junit.Assert.assertEquals;
+
 import com.google.gson.Gson;
-import junit.framework.TestCase;
+import org.junit.Before;
+import org.junit.Test;
 
 /**
  * Functional tests for internationalized strings.
  *
  * @author Inderjeet Singh
  */
-public class InternationalizationTest extends TestCase {
+public class InternationalizationTest {
   private Gson gson;
 
-  @Override
-  protected void setUp() throws Exception {
-    super.setUp();
+  @Before
+  public void setUp() throws Exception {
     gson = new Gson();
   }
 
+  @Test
   public void testStringsWithUnicodeChineseCharactersSerialization() throws Exception {
     String target = "\u597d\u597d\u597d";
     String json = gson.toJson(target);
@@ -40,6 +43,7 @@ public class InternationalizationTest extends TestCase {
     assertEquals(expected, json);
   }
 
+  @Test
   public void testStringsWithUnicodeChineseCharactersDeserialization() throws Exception {
     String expected = "\u597d\u597d\u597d";
     String json = '"' + expected + '"';
@@ -47,11 +51,13 @@ public class InternationalizationTest extends TestCase {
     assertEquals(expected, actual);
   }
 
+  @Test
   public void testStringsWithUnicodeChineseCharactersEscapedDeserialization() throws Exception {
     String actual = gson.fromJson("\"\\u597d\\u597d\\u597d\"", String.class);
     assertEquals("\u597d\u597d\u597d", actual);
   }
 
+  @Test
   public void testSupplementaryUnicodeSerialization() throws Exception {
     // Supplementary code point U+1F60A
     String supplementaryCodePoint = new String(new int[] {0x1F60A}, 0, 1);
@@ -59,6 +65,7 @@ public class InternationalizationTest extends TestCase {
     assertEquals('"' + supplementaryCodePoint + '"', json);
   }
 
+  @Test
   public void testSupplementaryUnicodeDeserialization() throws Exception {
     // Supplementary code point U+1F60A
     String supplementaryCodePoint = new String(new int[] {0x1F60A}, 0, 1);
@@ -66,6 +73,7 @@ public class InternationalizationTest extends TestCase {
     assertEquals(supplementaryCodePoint, actual);
   }
 
+  @Test
   public void testSupplementaryUnicodeEscapedDeserialization() throws Exception {
     // Supplementary code point U+1F60A
     String supplementaryCodePoint = new String(new int[] {0x1F60A}, 0, 1);
diff --git a/gson/src/test/java/com/google/gson/functional/JavaUtilConcurrentAtomicTest.java b/gson/src/test/java/com/google/gson/functional/JavaUtilConcurrentAtomicTest.java
index e5b175b3..2d81cc1e 100644
--- a/gson/src/test/java/com/google/gson/functional/JavaUtilConcurrentAtomicTest.java
+++ b/gson/src/test/java/com/google/gson/functional/JavaUtilConcurrentAtomicTest.java
@@ -16,30 +16,32 @@
 
 package com.google.gson.functional;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.LongSerializationPolicy;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicIntegerArray;
 import java.util.concurrent.atomic.AtomicLong;
 import java.util.concurrent.atomic.AtomicLongArray;
-
-import com.google.gson.Gson;
-import com.google.gson.GsonBuilder;
-import com.google.gson.LongSerializationPolicy;
-
-import junit.framework.TestCase;
+import org.junit.Before;
+import org.junit.Test;
 
 /**
  * Functional test for Json serialization and deserialization for classes in java.util.concurrent.atomic
  */
-public class JavaUtilConcurrentAtomicTest extends TestCase {
+public class JavaUtilConcurrentAtomicTest {
   private Gson gson;
 
-  @Override
-  protected void setUp() throws Exception {
-    super.setUp();
+  @Before
+  public void setUp() throws Exception {
     gson = new Gson();
   }
 
+  @Test
   public void testAtomicBoolean() throws Exception {
     AtomicBoolean target = gson.fromJson("true", AtomicBoolean.class);
     assertTrue(target.get());
@@ -47,6 +49,7 @@ public class JavaUtilConcurrentAtomicTest extends TestCase {
     assertEquals("true", json);
   }
 
+  @Test
   public void testAtomicInteger() throws Exception {
     AtomicInteger target = gson.fromJson("10", AtomicInteger.class);
     assertEquals(10, target.get());
@@ -54,6 +57,7 @@ public class JavaUtilConcurrentAtomicTest extends TestCase {
     assertEquals("10", json);
   }
 
+  @Test
   public void testAtomicLong() throws Exception {
     AtomicLong target = gson.fromJson("10", AtomicLong.class);
     assertEquals(10, target.get());
@@ -61,6 +65,7 @@ public class JavaUtilConcurrentAtomicTest extends TestCase {
     assertEquals("10", json);
   }
 
+  @Test
   public void testAtomicLongWithStringSerializationPolicy() throws Exception {
     Gson gson = new GsonBuilder()
         .setLongSerializationPolicy(LongSerializationPolicy.STRING)
@@ -71,6 +76,7 @@ public class JavaUtilConcurrentAtomicTest extends TestCase {
     assertEquals("{\"value\":\"10\"}", json);
   }
 
+  @Test
   public void testAtomicIntegerArray() throws Exception {
     AtomicIntegerArray target = gson.fromJson("[10, 13, 14]", AtomicIntegerArray.class);
     assertEquals(3, target.length());
@@ -81,6 +87,7 @@ public class JavaUtilConcurrentAtomicTest extends TestCase {
     assertEquals("[10,13,14]", json);
   }
 
+  @Test
   public void testAtomicLongArray() throws Exception {
     AtomicLongArray target = gson.fromJson("[10, 13, 14]", AtomicLongArray.class);
     assertEquals(3, target.length());
@@ -91,6 +98,7 @@ public class JavaUtilConcurrentAtomicTest extends TestCase {
     assertEquals("[10,13,14]", json);
   }
 
+  @Test
   public void testAtomicLongArrayWithStringSerializationPolicy() throws Exception {
     Gson gson = new GsonBuilder()
         .setLongSerializationPolicy(LongSerializationPolicy.STRING)
diff --git a/gson/src/test/java/com/google/gson/functional/JavaUtilTest.java b/gson/src/test/java/com/google/gson/functional/JavaUtilTest.java
index 9ed17bb8..da461079 100644
--- a/gson/src/test/java/com/google/gson/functional/JavaUtilTest.java
+++ b/gson/src/test/java/com/google/gson/functional/JavaUtilTest.java
@@ -16,25 +16,28 @@
 
 package com.google.gson.functional;
 
-import java.util.Currency;
-import java.util.Properties;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
 
 import com.google.gson.Gson;
-
-import junit.framework.TestCase;
+import java.util.Currency;
+import java.util.Properties;
+import org.junit.Before;
+import org.junit.Test;
 
 /**
  * Functional test for Json serialization and deserialization for classes in java.util
  */
-public class JavaUtilTest extends TestCase {
+public class JavaUtilTest {
   private Gson gson;
 
-  @Override
-  protected void setUp() throws Exception {
-    super.setUp();
+  @Before
+  public void setUp() throws Exception {
     gson = new Gson();
   }
 
+  @Test
   public void testCurrency() throws Exception {
     CurrencyHolder target = gson.fromJson("{\"value\":\"USD\"}", CurrencyHolder.class);
     assertEquals("USD", target.value.getCurrencyCode());
@@ -51,6 +54,7 @@ public class JavaUtilTest extends TestCase {
     Currency value;
   }
 
+  @Test
   public void testProperties() {
     Properties props = gson.fromJson("{\"a\":\"v1\",\"b\":\"v2\"}", Properties.class);
     assertEquals("v1", props.getProperty("a"));
diff --git a/gson/src/test/java/com/google/gson/functional/JsonAdapterAnnotationOnClassesTest.java b/gson/src/test/java/com/google/gson/functional/JsonAdapterAnnotationOnClassesTest.java
index 736ede33..62870b80 100644
--- a/gson/src/test/java/com/google/gson/functional/JsonAdapterAnnotationOnClassesTest.java
+++ b/gson/src/test/java/com/google/gson/functional/JsonAdapterAnnotationOnClassesTest.java
@@ -16,6 +16,11 @@
 
 package com.google.gson.functional;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.fail;
+
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
 import com.google.gson.JsonDeserializationContext;
@@ -34,13 +39,14 @@ import com.google.gson.stream.JsonWriter;
 import java.io.IOException;
 import java.lang.reflect.Type;
 import java.util.Locale;
-import junit.framework.TestCase;
+import org.junit.Test;
 
 /**
  * Functional tests for the {@link com.google.gson.annotations.JsonAdapter} annotation on classes.
  */
-public final class JsonAdapterAnnotationOnClassesTest extends TestCase {
+public final class JsonAdapterAnnotationOnClassesTest {
 
+  @Test
   public void testJsonAdapterInvoked() {
     Gson gson = new Gson();
     String json = gson.toJson(new A("bar"));
@@ -59,6 +65,7 @@ public final class JsonAdapterAnnotationOnClassesTest extends TestCase {
     assertEquals(Foo.BAZ, baz);
   }
 
+  @Test
   public void testJsonAdapterFactoryInvoked() {
     Gson gson = new Gson();
     String json = gson.toJson(new C("bar"));
@@ -67,6 +74,7 @@ public final class JsonAdapterAnnotationOnClassesTest extends TestCase {
     assertEquals("jsonAdapterFactory", c.value);
   }
 
+  @Test
   public void testRegisteredAdapterOverridesJsonAdapter() {
     TypeAdapter<A> typeAdapter = new TypeAdapter<A>() {
       @Override public void write(JsonWriter out, A value) throws IOException {
@@ -86,6 +94,7 @@ public final class JsonAdapterAnnotationOnClassesTest extends TestCase {
   /**
    * The serializer overrides field adapter, but for deserializer the fieldAdapter is used.
    */
+  @Test
   public void testRegisteredSerializerOverridesJsonAdapter() {
     JsonSerializer<A> serializer = new JsonSerializer<A>() {
       @Override public JsonElement serialize(A src, Type typeOfSrc,
@@ -106,6 +115,7 @@ public final class JsonAdapterAnnotationOnClassesTest extends TestCase {
   /**
    * The deserializer overrides Json adapter, but for serializer the jsonAdapter is used.
    */
+  @Test
   public void testRegisteredDeserializerOverridesJsonAdapter() {
     JsonDeserializer<A> deserializer = new JsonDeserializer<A>() {
       @Override public A deserialize(JsonElement json, Type typeOfT,
@@ -123,6 +133,7 @@ public final class JsonAdapterAnnotationOnClassesTest extends TestCase {
     assertEquals("registeredDeserializer", target.value);
   }
 
+  @Test
   public void testIncorrectTypeAdapterFails() {
     try {
       String json = new Gson().toJson(new ClassWithIncorrectJsonAdapter("bar"));
@@ -130,11 +141,13 @@ public final class JsonAdapterAnnotationOnClassesTest extends TestCase {
     } catch (ClassCastException expected) {}
   }
 
+  @Test
   public void testSuperclassTypeAdapterNotInvoked() {
     String json = new Gson().toJson(new B("bar"));
     assertFalse(json.contains("jsonAdapter"));
   }
 
+  @Test
   public void testNullSafeObjectFromJson() {
     Gson gson = new Gson();
     NullableClass fromJson = gson.fromJson("null", NullableClass.class);
@@ -252,6 +265,7 @@ public final class JsonAdapterAnnotationOnClassesTest extends TestCase {
     }
   }
 
+  @Test
   public void testIncorrectJsonAdapterType() {
     try {
       new Gson().toJson(new D());
diff --git a/gson/src/test/java/com/google/gson/functional/JsonAdapterAnnotationOnFieldsTest.java b/gson/src/test/java/com/google/gson/functional/JsonAdapterAnnotationOnFieldsTest.java
index e6996947..781df52a 100644
--- a/gson/src/test/java/com/google/gson/functional/JsonAdapterAnnotationOnFieldsTest.java
+++ b/gson/src/test/java/com/google/gson/functional/JsonAdapterAnnotationOnFieldsTest.java
@@ -16,9 +16,9 @@
 
 package com.google.gson.functional;
 
-import java.io.IOException;
-import java.util.Arrays;
-import java.util.List;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
 
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
@@ -28,13 +28,16 @@ import com.google.gson.annotations.JsonAdapter;
 import com.google.gson.reflect.TypeToken;
 import com.google.gson.stream.JsonReader;
 import com.google.gson.stream.JsonWriter;
-
-import junit.framework.TestCase;
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.List;
+import org.junit.Test;
 
 /**
  * Functional tests for the {@link com.google.gson.annotations.JsonAdapter} annotation on fields.
  */
-public final class JsonAdapterAnnotationOnFieldsTest extends TestCase {
+public final class JsonAdapterAnnotationOnFieldsTest {
+  @Test
   public void testClassAnnotationAdapterTakesPrecedenceOverDefault() {
     Gson gson = new Gson();
     String json = gson.toJson(new Computer(new User("Inderjeet Singh")));
@@ -43,6 +46,7 @@ public final class JsonAdapterAnnotationOnFieldsTest extends TestCase {
     assertEquals("UserClassAnnotationAdapter", computer.user.name);
   }
 
+  @Test
   public void testClassAnnotationAdapterFactoryTakesPrecedenceOverDefault() {
     Gson gson = new Gson();
     String json = gson.toJson(new Gizmo(new Part("Part")));
@@ -51,6 +55,7 @@ public final class JsonAdapterAnnotationOnFieldsTest extends TestCase {
     assertEquals("GizmoPartTypeAdapterFactory", computer.part.name);
   }
 
+  @Test
   public void testRegisteredTypeAdapterTakesPrecedenceOverClassAnnotationAdapter() {
     Gson gson = new GsonBuilder()
         .registerTypeAdapter(User.class, new RegisteredUserAdapter())
@@ -61,6 +66,7 @@ public final class JsonAdapterAnnotationOnFieldsTest extends TestCase {
     assertEquals("RegisteredUserAdapter", computer.user.name);
   }
 
+  @Test
   public void testFieldAnnotationTakesPrecedenceOverRegisteredTypeAdapter() {
     Gson gson = new GsonBuilder()
       .setLenient()
@@ -78,6 +84,7 @@ public final class JsonAdapterAnnotationOnFieldsTest extends TestCase {
     assertEquals("PartJsonFieldAnnotationAdapter", gadget.part.name);
   }
 
+  @Test
   public void testFieldAnnotationTakesPrecedenceOverClassAnnotation() {
     Gson gson = new Gson();
     String json = gson.toJson(new Computer2(new User("Inderjeet Singh")));
@@ -188,6 +195,7 @@ public final class JsonAdapterAnnotationOnFieldsTest extends TestCase {
     }
   }
 
+  @Test
   public void testJsonAdapterInvokedOnlyForAnnotatedFields() {
     Gson gson = new Gson();
     String json = "{'part1':'name','part2':{'name':'name2'}}";
@@ -205,6 +213,7 @@ public final class JsonAdapterAnnotationOnFieldsTest extends TestCase {
     }
   }
 
+  @Test
   public void testJsonAdapterWrappedInNullSafeAsRequested() {
     Gson gson = new Gson();
     String fromJson = "{'part':null}";
@@ -226,6 +235,7 @@ public final class JsonAdapterAnnotationOnFieldsTest extends TestCase {
   }
 
   /** Regression test contributed through https://github.com/google/gson/issues/831 */
+  @Test
   public void testNonPrimitiveFieldAnnotationTakesPrecedenceOverDefault() {
     Gson gson = new Gson();
     String json = gson.toJson(new GadgetWithOptionalPart(new Part("foo")));
@@ -235,6 +245,7 @@ public final class JsonAdapterAnnotationOnFieldsTest extends TestCase {
   }
 
   /** Regression test contributed through https://github.com/google/gson/issues/831 */
+  @Test
   public void testPrimitiveFieldAnnotationTakesPrecedenceOverDefault() {
     Gson gson = new Gson();
     String json = gson.toJson(new GadgetWithPrimitivePart(42));
@@ -274,6 +285,7 @@ public final class JsonAdapterAnnotationOnFieldsTest extends TestCase {
     }
   }
 
+  @Test
   public void testFieldAnnotationWorksForParameterizedType() {
     Gson gson = new Gson();
     String json = gson.toJson(new Gizmo2(Arrays.asList(new Part("Part"))));
diff --git a/gson/src/test/java/com/google/gson/functional/JsonAdapterSerializerDeserializerTest.java b/gson/src/test/java/com/google/gson/functional/JsonAdapterSerializerDeserializerTest.java
index f5398843..e206ea96 100644
--- a/gson/src/test/java/com/google/gson/functional/JsonAdapterSerializerDeserializerTest.java
+++ b/gson/src/test/java/com/google/gson/functional/JsonAdapterSerializerDeserializerTest.java
@@ -16,7 +16,9 @@
 
 package com.google.gson.functional;
 
-import java.lang.reflect.Type;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
 
 import com.google.gson.Gson;
 import com.google.gson.JsonDeserializationContext;
@@ -27,15 +29,16 @@ import com.google.gson.JsonPrimitive;
 import com.google.gson.JsonSerializationContext;
 import com.google.gson.JsonSerializer;
 import com.google.gson.annotations.JsonAdapter;
-
-import junit.framework.TestCase;
+import java.lang.reflect.Type;
+import org.junit.Test;
 
 /**
  * Functional tests for the {@link JsonAdapter} annotation on fields where the value is of
  * type {@link JsonSerializer} or {@link JsonDeserializer}.
  */
-public final class JsonAdapterSerializerDeserializerTest extends TestCase {
+public final class JsonAdapterSerializerDeserializerTest {
 
+  @Test
   public void testJsonSerializerDeserializerBasedJsonAdapterOnFields() {
     Gson gson = new Gson();
     String json = gson.toJson(new Computer(new User("Inderjeet Singh"), null, new User("Jesse Wilson")));
@@ -90,6 +93,7 @@ public final class JsonAdapterSerializerDeserializerTest extends TestCase {
     }
   }
 
+  @Test
   public void testJsonSerializerDeserializerBasedJsonAdapterOnClass() {
     Gson gson = new Gson();
     String json = gson.toJson(new Computer2(new User2("Inderjeet Singh")));
@@ -125,6 +129,7 @@ public final class JsonAdapterSerializerDeserializerTest extends TestCase {
     }
   }
 
+  @Test
   public void testDifferentJsonAdaptersForGenericFieldsOfSameRawType() {
     Container c = new Container("Foo", 10);
     Gson gson = new Gson();
@@ -162,6 +167,7 @@ public final class JsonAdapterSerializerDeserializerTest extends TestCase {
     }
   }
 
+  @Test
   public void testJsonAdapterNullSafe() {
     Gson gson = new Gson();
     String json = gson.toJson(new Computer3(null, null));
diff --git a/gson/src/test/java/com/google/gson/functional/JsonParserTest.java b/gson/src/test/java/com/google/gson/functional/JsonParserTest.java
index d87c8981..88c53f63 100644
--- a/gson/src/test/java/com/google/gson/functional/JsonParserTest.java
+++ b/gson/src/test/java/com/google/gson/functional/JsonParserTest.java
@@ -16,18 +16,20 @@
 
 package com.google.gson.functional;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
 import com.google.gson.*;
 import com.google.gson.common.TestTypes.BagOfPrimitives;
 import com.google.gson.common.TestTypes.Nested;
 import com.google.gson.reflect.TypeToken;
-
-import junit.framework.TestCase;
-
 import java.io.StringReader;
 import java.lang.reflect.Type;
 import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
+import org.junit.Before;
+import org.junit.Test;
 
 /**
  * Functional tests for that use JsonParser and related Gson methods
@@ -35,15 +37,15 @@ import java.util.Map;
  * @author Inderjeet Singh
  * @author Joel Leitch
  */
-public class JsonParserTest extends TestCase {
+public class JsonParserTest {
   private Gson gson;
 
-  @Override
-  protected void setUp() throws Exception {
-    super.setUp();
+  @Before
+  public void setUp() throws Exception {
     gson = new Gson();
   }
 
+  @Test
   public void testParseInvalidJson() {
     try {
       gson.fromJson("[[]", Object[].class);
@@ -51,6 +53,7 @@ public class JsonParserTest extends TestCase {
     } catch (JsonSyntaxException expected) { }
   }
 
+  @Test
   public void testDeserializingCustomTree() {
     JsonObject obj = new JsonObject();
     obj.addProperty("stringValue", "foo");
@@ -60,6 +63,7 @@ public class JsonParserTest extends TestCase {
     assertEquals("foo", target.stringValue);
   }
 
+  @Test
   public void testBadTypeForDeserializingCustomTree() {
     JsonObject obj = new JsonObject();
     obj.addProperty("stringValue", "foo");
@@ -72,6 +76,7 @@ public class JsonParserTest extends TestCase {
     } catch (JsonParseException expected) { }
   }
 
+  @Test
   public void testBadFieldTypeForCustomDeserializerCustomTree() {
     JsonArray array = new JsonArray();
     array.add(new JsonPrimitive("blah"));
@@ -86,6 +91,7 @@ public class JsonParserTest extends TestCase {
     } catch (JsonParseException expected) { }
   }
 
+  @Test
   public void testBadFieldTypeForDeserializingCustomTree() {
     JsonArray array = new JsonArray();
     array.add(new JsonPrimitive("blah"));
@@ -103,6 +109,7 @@ public class JsonParserTest extends TestCase {
     } catch (JsonParseException expected) { }
   }
 
+  @Test
   public void testChangingCustomTreeAndDeserializing() {
     StringReader json =
       new StringReader("{'stringValue':'no message','intValue':10,'longValue':20}");
@@ -115,6 +122,7 @@ public class JsonParserTest extends TestCase {
     assertEquals("fooBar", target.stringValue);
   }
 
+  @Test
   public void testExtraCommasInArrays() {
     Type type = new TypeToken<List<String>>() {}.getType();
     assertEquals(Arrays.asList("a", "b"), gson.fromJson("[a,,b,,]", type));
@@ -122,6 +130,7 @@ public class JsonParserTest extends TestCase {
     assertEquals(Arrays.asList("a"), gson.fromJson("[a,]", type));
   }
 
+  @Test
   public void testExtraCommasInMaps() {
     Type type = new TypeToken<Map<String, String>>() {}.getType();
     try {
diff --git a/gson/src/test/java/com/google/gson/functional/JsonTreeTest.java b/gson/src/test/java/com/google/gson/functional/JsonTreeTest.java
index a6479403..5f7bd7e5 100644
--- a/gson/src/test/java/com/google/gson/functional/JsonTreeTest.java
+++ b/gson/src/test/java/com/google/gson/functional/JsonTreeTest.java
@@ -1,5 +1,10 @@
 package com.google.gson.functional;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
 import com.google.gson.Gson;
 import com.google.gson.JsonElement;
 import com.google.gson.JsonObject;
@@ -8,7 +13,8 @@ import com.google.gson.common.TestTypes.BagOfPrimitives;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.Set;
-import junit.framework.TestCase;
+import org.junit.Before;
+import org.junit.Test;
 
 /**
  * Functional tests for {@link Gson#toJsonTree(Object)} and 
@@ -17,15 +23,15 @@ import junit.framework.TestCase;
  * @author Inderjeet Singh
  * @author Joel Leitch
  */
-public class JsonTreeTest extends TestCase {
+public class JsonTreeTest {
   private Gson gson;
 
-  @Override
-  protected void setUp() throws Exception {
-    super.setUp();
+  @Before
+  public void setUp() throws Exception {
     gson = new Gson();
   }
 
+  @Test
   public void testToJsonTree() {
     BagOfPrimitives bag = new BagOfPrimitives(10L, 5, false, "foo");
     JsonElement json = gson.toJsonTree(bag);
@@ -39,6 +45,7 @@ public class JsonTreeTest extends TestCase {
     assertContains(obj, new JsonPrimitive("foo"));
   }
 
+  @Test
   public void testToJsonTreeObjectType() {
     SubTypeOfBagOfPrimitives bag = new SubTypeOfBagOfPrimitives(10L, 5, false, "foo", 1.4F);
     JsonElement json = gson.toJsonTree(bag, BagOfPrimitives.class);
@@ -52,6 +59,7 @@ public class JsonTreeTest extends TestCase {
     assertContains(obj, new JsonPrimitive("foo"));
   }
 
+  @Test
   public void testJsonTreeToString() {
     SubTypeOfBagOfPrimitives bag = new SubTypeOfBagOfPrimitives(10L, 5, false, "foo", 1.4F);
     String json1 = gson.toJson(bag);
@@ -60,6 +68,7 @@ public class JsonTreeTest extends TestCase {
     assertEquals(json1, json2);
   }
 
+  @Test
   public void testJsonTreeNull() {
     BagOfPrimitives bag = new BagOfPrimitives(10L, 5, false, null);
     JsonObject jsonElement = (JsonObject) gson.toJsonTree(bag, BagOfPrimitives.class);
diff --git a/gson/src/test/java/com/google/gson/functional/LeniencyTest.java b/gson/src/test/java/com/google/gson/functional/LeniencyTest.java
index cd662d44..6d32e989 100644
--- a/gson/src/test/java/com/google/gson/functional/LeniencyTest.java
+++ b/gson/src/test/java/com/google/gson/functional/LeniencyTest.java
@@ -15,27 +15,29 @@
  */
 package com.google.gson.functional;
 
+import static java.util.Collections.singletonList;
+import static org.junit.Assert.assertEquals;
+
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
 import com.google.gson.reflect.TypeToken;
 import java.util.List;
-import junit.framework.TestCase;
-
-import static java.util.Collections.singletonList;
+import org.junit.Before;
+import org.junit.Test;
 
 /**
  * Functional tests for leniency option.
  */
-public class LeniencyTest extends TestCase {
+public class LeniencyTest {
 
   private Gson gson;
 
-  @Override
-  protected void setUp() throws Exception {
-    super.setUp();
+  @Before
+  public void setUp() throws Exception {
     gson = new Gson();
   }
 
+  @Test
   public void testLenientFromJson() {
     List<String> json = gson.fromJson(""
         + "[ # One!\n"
diff --git a/gson/src/test/java/com/google/gson/functional/MapAsArrayTypeAdapterTest.java b/gson/src/test/java/com/google/gson/functional/MapAsArrayTypeAdapterTest.java
index 65ab8bdd..7dd9a6b4 100644
--- a/gson/src/test/java/com/google/gson/functional/MapAsArrayTypeAdapterTest.java
+++ b/gson/src/test/java/com/google/gson/functional/MapAsArrayTypeAdapterTest.java
@@ -16,6 +16,9 @@
 
 package com.google.gson.functional;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
 import com.google.gson.JsonSyntaxException;
@@ -24,10 +27,12 @@ import java.lang.reflect.Type;
 import java.util.HashMap;
 import java.util.LinkedHashMap;
 import java.util.Map;
-import junit.framework.TestCase;
+import org.junit.Ignore;
+import org.junit.Test;
 
-public class MapAsArrayTypeAdapterTest extends TestCase {
+public class MapAsArrayTypeAdapterTest {
 
+  @Test
   public void testSerializeComplexMapWithTypeAdapter() {
     Type type = new TypeToken<Map<Point, String>>() {}.getType();
     Gson gson = new GsonBuilder()
@@ -53,6 +58,8 @@ public class MapAsArrayTypeAdapterTest extends TestCase {
         new TypeToken<Map<String, Boolean>>() {}.getType()));
   }
 
+  @Test
+  @Ignore
   public void disabled_testTwoTypesCollapseToOneSerialize() {
     Gson gson = new GsonBuilder()
         .enableComplexMapKeySerialization()
@@ -68,6 +75,7 @@ public class MapAsArrayTypeAdapterTest extends TestCase {
     }
   }
 
+  @Test
   public void testTwoTypesCollapseToOneDeserialize() {
     Gson gson = new GsonBuilder()
         .enableComplexMapKeySerialization()
@@ -81,6 +89,7 @@ public class MapAsArrayTypeAdapterTest extends TestCase {
     }
   }
 
+  @Test
   public void testMultipleEnableComplexKeyRegistrationHasNoEffect() throws Exception {
     Type type = new TypeToken<Map<Point, String>>() {}.getType();
     Gson gson = new GsonBuilder()
@@ -96,6 +105,7 @@ public class MapAsArrayTypeAdapterTest extends TestCase {
     assertEquals(original, gson.<Map<Point, String>>fromJson(json, type));
   }
 
+  @Test
   public void testMapWithTypeVariableSerialization() {
     Gson gson = new GsonBuilder().enableComplexMapKeySerialization().create();
     PointWithProperty<Point> map = new PointWithProperty<>();
@@ -105,6 +115,7 @@ public class MapAsArrayTypeAdapterTest extends TestCase {
     assertEquals("{\"map\":[[{\"x\":2,\"y\":3},{\"x\":4,\"y\":5}]]}", json);
   }
 
+  @Test
   public void testMapWithTypeVariableDeserialization() {
     Gson gson = new GsonBuilder().setLenient().enableComplexMapKeySerialization().create();
     String json = "{map:[[{x:2,y:3},{x:4,y:5}]]}";
diff --git a/gson/src/test/java/com/google/gson/functional/MapTest.java b/gson/src/test/java/com/google/gson/functional/MapTest.java
index 439c8d39..07ff485f 100644
--- a/gson/src/test/java/com/google/gson/functional/MapTest.java
+++ b/gson/src/test/java/com/google/gson/functional/MapTest.java
@@ -16,6 +16,12 @@
 
 package com.google.gson.functional;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
 import com.google.gson.InstanceCreator;
@@ -41,7 +47,8 @@ import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
 import java.util.concurrent.ConcurrentNavigableMap;
 import java.util.concurrent.ConcurrentSkipListMap;
-import junit.framework.TestCase;
+import org.junit.Before;
+import org.junit.Test;
 
 /**
  * Functional test for Json serialization and deserialization for Maps
@@ -49,15 +56,15 @@ import junit.framework.TestCase;
  * @author Inderjeet Singh
  * @author Joel Leitch
  */
-public class MapTest extends TestCase {
+public class MapTest {
   private Gson gson;
 
-  @Override
-  protected void setUp() throws Exception {
-    super.setUp();
+  @Before
+  public void setUp() throws Exception {
     gson = new Gson();
   }
 
+  @Test
   public void testMapSerialization() {
     Map<String, Integer> map = new LinkedHashMap<>();
     map.put("a", 1);
@@ -68,6 +75,7 @@ public class MapTest extends TestCase {
     assertTrue(json.contains("\"b\":2"));
   }
 
+  @Test
   public void testMapDeserialization() {
     String json = "{\"a\":1,\"b\":2}";
     Type typeOfMap = new TypeToken<Map<String,Integer>>(){}.getType();
@@ -76,17 +84,19 @@ public class MapTest extends TestCase {
     assertEquals(2, target.get("b").intValue());
   }
 
-    public void testMapDuplicateKeyDeserialization() {
-        Gson gsonWithDuplicateKeys = new GsonBuilder()
-                .enableDuplicateMapKeyDeserialization()
-                .create();
-        Type typeOfMap = new TypeToken<Map<String,Integer>>(){}.getType();
-        String json = "{\"a\":1,\"b\":2,\"b\":3}";
-        Map<String,Integer> target = gsonWithDuplicateKeys.fromJson(json, typeOfMap);
-        assertEquals(1, target.get("a").intValue());
-        assertEquals(3, target.get("b").intValue());
-    }
+  @Test
+  public void testMapDuplicateKeyDeserialization() {
+    Gson gsonWithDuplicateKeys = new GsonBuilder()
+            .enableDuplicateMapKeyDeserialization()
+            .create();
+    Type typeOfMap = new TypeToken<Map<String,Integer>>(){}.getType();
+    String json = "{\"a\":1,\"b\":2,\"b\":3}";
+    Map<String,Integer> target = gsonWithDuplicateKeys.fromJson(json, typeOfMap);
+    assertEquals(1, target.get("a").intValue());
+    assertEquals(3, target.get("b").intValue());
+  }
 
+  @Test
   public void testObjectMapSerialization() {
     Map<String, Object> map = new LinkedHashMap<>();
     map.put("a", 1);
@@ -96,6 +106,7 @@ public class MapTest extends TestCase {
     assertTrue(json.contains("\"b\":\"string\""));
   }
 
+  @Test
   public void testMapSerializationEmpty() {
     Map<String, Integer> map = new LinkedHashMap<>();
     Type typeOfMap = new TypeToken<Map<String, Integer>>() {}.getType();
@@ -103,12 +114,14 @@ public class MapTest extends TestCase {
     assertEquals("{}", json);
   }
 
+  @Test
   public void testMapDeserializationEmpty() {
     Type typeOfMap = new TypeToken<Map<String, Integer>>() {}.getType();
     Map<String, Integer> map = gson.fromJson("{}", typeOfMap);
     assertTrue(map.isEmpty());
   }
 
+  @Test
   public void testMapSerializationWithNullValue() {
     Map<String, Integer> map = new LinkedHashMap<>();
     map.put("abc", null);
@@ -119,6 +132,7 @@ public class MapTest extends TestCase {
     assertEquals("{}", json);
   }
 
+  @Test
   public void testMapDeserializationWithNullValue() {
     Type typeOfMap = new TypeToken<Map<String, Integer>>() {}.getType();
     Map<String, Integer> map = gson.fromJson("{\"abc\":null}", typeOfMap);
@@ -126,6 +140,7 @@ public class MapTest extends TestCase {
     assertNull(map.get("abc"));
   }
 
+  @Test
   public void testMapSerializationWithNullValueButSerializeNulls() {
     gson = new GsonBuilder().serializeNulls().create();
     Map<String, Integer> map = new LinkedHashMap<>();
@@ -136,6 +151,7 @@ public class MapTest extends TestCase {
     assertEquals("{\"abc\":null}", json);
   }
 
+  @Test
   public void testMapSerializationWithNullKey() {
     Map<String, Integer> map = new LinkedHashMap<>();
     map.put(null, 123);
@@ -145,6 +161,7 @@ public class MapTest extends TestCase {
     assertEquals("{\"null\":123}", json);
   }
 
+  @Test
   public void testMapDeserializationWithNullKey() {
     Type typeOfMap = new TypeToken<Map<String, Integer>>() {}.getType();
     Map<String, Integer> map = gson.fromJson("{\"null\":123}", typeOfMap);
@@ -158,6 +175,7 @@ public class MapTest extends TestCase {
     assertNull(map.get(null));
   }
 
+  @Test
   public void testMapSerializationWithIntegerKeys() {
     Map<Integer, String> map = new LinkedHashMap<>();
     map.put(123, "456");
@@ -167,6 +185,7 @@ public class MapTest extends TestCase {
     assertEquals("{\"123\":\"456\"}", json);
   }
 
+  @Test
   public void testMapDeserializationWithIntegerKeys() {
     Type typeOfMap = new TypeToken<Map<Integer, String>>() {}.getType();
     Map<Integer, String> map = gson.fromJson("{\"123\":\"456\"}", typeOfMap);
@@ -175,6 +194,7 @@ public class MapTest extends TestCase {
     assertEquals("456", map.get(123));
   }
 
+  @Test
   public void testMapDeserializationWithUnquotedIntegerKeys() {
     Type typeOfMap = new TypeToken<Map<Integer, String>>() {}.getType();
     Map<Integer, String> map = gson.fromJson("{123:\"456\"}", typeOfMap);
@@ -183,6 +203,7 @@ public class MapTest extends TestCase {
     assertEquals("456", map.get(123));
   }
 
+  @Test
   public void testMapDeserializationWithLongKeys() {
     long longValue = 9876543210L;
     String json = String.format("{\"%d\":\"456\"}", longValue);
@@ -193,6 +214,7 @@ public class MapTest extends TestCase {
     assertEquals("456", map.get(longValue));
   }
 
+  @Test
   public void testMapDeserializationWithUnquotedLongKeys() {
     long longKey = 9876543210L;
     String json = String.format("{%d:\"456\"}", longKey);
@@ -203,6 +225,7 @@ public class MapTest extends TestCase {
     assertEquals("456", map.get(longKey));
   }
 
+  @Test
   public void testHashMapDeserialization() throws Exception {
     Type typeOfMap = new TypeToken<HashMap<Integer, String>>() {}.getType();
     HashMap<Integer, String> map = gson.fromJson("{\"123\":\"456\"}", typeOfMap);
@@ -211,6 +234,7 @@ public class MapTest extends TestCase {
     assertEquals("456", map.get(123));
   }
 
+  @Test
   public void testSortedMap() throws Exception {
     Type typeOfMap = new TypeToken<SortedMap<Integer, String>>() {}.getType();
     SortedMap<Integer, String> map = gson.fromJson("{\"123\":\"456\"}", typeOfMap);
@@ -219,6 +243,7 @@ public class MapTest extends TestCase {
     assertEquals("456", map.get(123));
   }
 
+  @Test
   public void testConcurrentMap() throws Exception {
     Type typeOfMap = new TypeToken<ConcurrentMap<Integer, String>>() {}.getType();
     ConcurrentMap<Integer, String> map = gson.fromJson("{\"123\":\"456\"}", typeOfMap);
@@ -229,6 +254,7 @@ public class MapTest extends TestCase {
     assertEquals("{\"123\":\"456\"}", json);
   }
 
+  @Test
   public void testConcurrentHashMap() throws Exception {
     Type typeOfMap = new TypeToken<ConcurrentHashMap<Integer, String>>() {}.getType();
     ConcurrentHashMap<Integer, String> map = gson.fromJson("{\"123\":\"456\"}", typeOfMap);
@@ -239,6 +265,7 @@ public class MapTest extends TestCase {
     assertEquals("{\"123\":\"456\"}", json);
   }
 
+  @Test
   public void testConcurrentNavigableMap() throws Exception {
     Type typeOfMap = new TypeToken<ConcurrentNavigableMap<Integer, String>>() {}.getType();
     ConcurrentNavigableMap<Integer, String> map = gson.fromJson("{\"123\":\"456\"}", typeOfMap);
@@ -249,6 +276,7 @@ public class MapTest extends TestCase {
     assertEquals("{\"123\":\"456\"}", json);
   }
 
+  @Test
   public void testConcurrentSkipListMap() throws Exception {
     Type typeOfMap = new TypeToken<ConcurrentSkipListMap<Integer, String>>() {}.getType();
     ConcurrentSkipListMap<Integer, String> map = gson.fromJson("{\"123\":\"456\"}", typeOfMap);
@@ -259,6 +287,7 @@ public class MapTest extends TestCase {
     assertEquals("{\"123\":\"456\"}", json);
   }
 
+  @Test
   public void testParameterizedMapSubclassSerialization() {
     MyParameterizedMap<String, String> map = new MyParameterizedMap<>(10);
     map.put("a", "b");
@@ -275,6 +304,7 @@ public class MapTest extends TestCase {
     }
   }
 
+  @Test
   public void testMapSubclassSerialization() {
     MyMap map = new MyMap();
     map.put("a", "b");
@@ -282,6 +312,7 @@ public class MapTest extends TestCase {
     assertTrue(json.contains("\"a\":\"b\""));
   }
 
+  @Test
   public void testMapStandardSubclassDeserialization() {
     String json = "{a:'1',b:'2'}";
     Type type = new TypeToken<LinkedHashMap<String, String>>() {}.getType();
@@ -290,6 +321,7 @@ public class MapTest extends TestCase {
     assertEquals("2", map.get("b"));
   }
 
+  @Test
   public void testMapSubclassDeserialization() {
     Gson gson = new GsonBuilder().registerTypeAdapter(MyMap.class, new InstanceCreator<MyMap>() {
       @Override public MyMap createInstance(Type type) {
@@ -302,6 +334,7 @@ public class MapTest extends TestCase {
     assertEquals("2", map.get("b"));
   }
 
+  @Test
   public void testCustomSerializerForSpecificMapType() {
     Type type = $Gson$Types.newParameterizedTypeWithOwner(
         null, Map.class, String.class, Long.class);
@@ -335,6 +368,7 @@ public class MapTest extends TestCase {
   /**
    * Created in response to http://code.google.com/p/google-gson/issues/detail?id=99
    */
+  @Test
   public void testMapSerializationWithNullValues() {
     ClassWithAMap target = new ClassWithAMap();
     target.map.put("name1", null);
@@ -347,6 +381,7 @@ public class MapTest extends TestCase {
   /**
    * Created in response to http://code.google.com/p/google-gson/issues/detail?id=99
    */
+  @Test
   public void testMapSerializationWithNullValuesSerialized() {
     Gson gson = new GsonBuilder().serializeNulls().create();
     ClassWithAMap target = new ClassWithAMap();
@@ -357,6 +392,7 @@ public class MapTest extends TestCase {
     assertTrue(json.contains("name2"));
   }
 
+  @Test
   public void testMapSerializationWithWildcardValues() {
     Map<String, ? extends Collection<? extends Integer>> map = new LinkedHashMap<>();
     map.put("test", null);
@@ -367,6 +403,7 @@ public class MapTest extends TestCase {
     assertEquals("{}", json);
   }
 
+  @Test
   public void testMapDeserializationWithWildcardValues() {
     Type typeOfMap = new TypeToken<Map<String, ? extends Long>>() {}.getType();
     Map<String, ? extends Long> map = gson.fromJson("{\"test\":123}", typeOfMap);
@@ -385,6 +422,7 @@ public class MapTest extends TestCase {
   /**
    * From bug report http://code.google.com/p/google-gson/issues/detail?id=95
    */
+  @Test
   public void testMapOfMapSerialization() {
     Map<String, Map<String, String>> map = new HashMap<>();
     Map<String, String> nestedMap = new HashMap<>();
@@ -400,6 +438,7 @@ public class MapTest extends TestCase {
   /**
    * From bug report http://code.google.com/p/google-gson/issues/detail?id=95
    */
+  @Test
   public void testMapOfMapDeserialization() {
     String json = "{nestedMap:{'2':'2','1':'1'}}";
     Type type = new TypeToken<Map<String, Map<String, String>>>(){}.getType();
@@ -412,6 +451,7 @@ public class MapTest extends TestCase {
   /**
    * From bug report http://code.google.com/p/google-gson/issues/detail?id=178
    */
+  @Test
   public void testMapWithQuotes() {
     Map<String, String> map = new HashMap<>();
     map.put("a\"b", "c\"d");
@@ -422,6 +462,7 @@ public class MapTest extends TestCase {
   /**
    * From issue 227.
    */
+  @Test
   public void testWriteMapsWithEmptyStringKey() {
     Map<String, Boolean> map = new HashMap<>();
     map.put("", true);
@@ -429,6 +470,7 @@ public class MapTest extends TestCase {
 
   }
 
+  @Test
   public void testReadMapsWithEmptyStringKey() {
     Map<String, Boolean> map = gson.fromJson("{\"\":true}", new TypeToken<Map<String, Boolean>>() {}.getType());
     assertEquals(Boolean.TRUE, map.get(""));
@@ -437,6 +479,7 @@ public class MapTest extends TestCase {
   /**
    * From bug report http://code.google.com/p/google-gson/issues/detail?id=204
    */
+  @Test
   public void testSerializeMaps() {
     Map<String, Object> map = new LinkedHashMap<>();
     map.put("a", 12);
@@ -465,6 +508,7 @@ public class MapTest extends TestCase {
         new Gson().toJson(map));
   }
 
+  @Test
   public final void testInterfaceTypeMap() {
     MapClass element = new MapClass();
     TestTypes.Sub subType = new TestTypes.Sub();
@@ -486,6 +530,7 @@ public class MapTest extends TestCase {
     assertEquals(expected, json);
   }
 
+  @Test
   public final void testInterfaceTypeMapWithSerializer() {
     MapClass element = new MapClass();
     TestTypes.Sub subType = new TestTypes.Sub();
@@ -520,6 +565,7 @@ public class MapTest extends TestCase {
     assertEquals(expected, json);
   }
 
+  @Test
   public void testGeneralMapField() throws Exception {
     MapWithGeneralMapParameters map = new MapWithGeneralMapParameters();
     map.map.put("string", "testString");
@@ -536,6 +582,7 @@ public class MapTest extends TestCase {
     assertEquals(expected, gson.toJson(map));
   }
 
+  @Test
   public void testComplexKeysSerialization() {
     Map<Point, String> map = new LinkedHashMap<>();
     map.put(new Point(2, 3), "a");
@@ -545,6 +592,7 @@ public class MapTest extends TestCase {
     assertEquals(json, gson.toJson(map, Map.class));
   }
 
+  @Test
   public void testComplexKeysDeserialization() {
     String json = "{'2,3':'a','5,7':'b'}";
     try {
@@ -554,6 +602,7 @@ public class MapTest extends TestCase {
     }
   }
 
+  @Test
   public void testStringKeyDeserialization() {
     String json = "{'2,3':'a','5,7':'b'}";
     Map<String, String> map = new LinkedHashMap<>();
@@ -562,6 +611,7 @@ public class MapTest extends TestCase {
     assertEquals(map, gson.fromJson(json, new TypeToken<Map<String, String>>() {}.getType()));
   }
 
+  @Test
   public void testNumberKeyDeserialization() {
     String json = "{'2.3':'a','5.7':'b'}";
     Map<Double, String> map = new LinkedHashMap<>();
@@ -570,6 +620,7 @@ public class MapTest extends TestCase {
     assertEquals(map, gson.fromJson(json, new TypeToken<Map<Double, String>>() {}.getType()));
   }
 
+  @Test
   public void testBooleanKeyDeserialization() {
     String json = "{'true':'a','false':'b'}";
     Map<Boolean, String> map = new LinkedHashMap<>();
@@ -578,6 +629,7 @@ public class MapTest extends TestCase {
     assertEquals(map, gson.fromJson(json, new TypeToken<Map<Boolean, String>>() {}.getType()));
   }
 
+  @Test
   public void testMapDeserializationWithDuplicateKeys() {
     try {
       gson.fromJson("{'a':1,'a':2}", new TypeToken<Map<String, Integer>>() {}.getType());
@@ -586,6 +638,7 @@ public class MapTest extends TestCase {
     }
   }
 
+  @Test
   public void testSerializeMapOfMaps() {
     Type type = new TypeToken<Map<String, Map<String, String>>>() {}.getType();
     Map<String, Map<String, String>> map = newMap(
@@ -595,6 +648,7 @@ public class MapTest extends TestCase {
         gson.toJson(map, type).replace('"', '\''));
   }
 
+  @Test
   public void testDeerializeMapOfMaps() {
     Type type = new TypeToken<Map<String, Map<String, String>>>() {}.getType();
     Map<String, Map<String, String>> map = newMap(
@@ -611,6 +665,7 @@ public class MapTest extends TestCase {
     return result;
   }
 
+  @Test
   public void testMapNamePromotionWithJsonElementReader() {
     String json = "{'2.3':'a'}";
     Map<Double, String> map = new LinkedHashMap<>();
diff --git a/gson/src/test/java/com/google/gson/functional/MoreSpecificTypeSerializationTest.java b/gson/src/test/java/com/google/gson/functional/MoreSpecificTypeSerializationTest.java
index a179fa8e..1b6ed887 100644
--- a/gson/src/test/java/com/google/gson/functional/MoreSpecificTypeSerializationTest.java
+++ b/gson/src/test/java/com/google/gson/functional/MoreSpecificTypeSerializationTest.java
@@ -16,15 +16,19 @@
 
 package com.google.gson.functional;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
 import com.google.gson.Gson;
 import com.google.gson.JsonObject;
-
-import junit.framework.TestCase;
-
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.Map;
+import org.junit.Before;
+import org.junit.Test;
 
 /**
  * Tests for Gson serialization of a sub-class object while encountering a base-class type
@@ -32,15 +36,15 @@ import java.util.Map;
  * @author Inderjeet Singh
  */
 @SuppressWarnings("unused")
-public class MoreSpecificTypeSerializationTest extends TestCase {
+public class MoreSpecificTypeSerializationTest {
   private Gson gson;
 
-  @Override
-  protected void setUp() throws Exception {
-    super.setUp();
+  @Before
+  public void setUp() throws Exception {
     gson = new Gson();
   }
 
+  @Test
   public void testSubclassFields() {
     ClassWithBaseFields target = new ClassWithBaseFields(new Sub(1, 2));
     String json = gson.toJson(target);
@@ -48,6 +52,7 @@ public class MoreSpecificTypeSerializationTest extends TestCase {
     assertTrue(json.contains("\"s\":2"));
   }
 
+  @Test
   public void testListOfSubclassFields() {
     Collection<Base> list = new ArrayList<>();
     list.add(new Base(1));
@@ -58,6 +63,7 @@ public class MoreSpecificTypeSerializationTest extends TestCase {
     assertTrue(json, json.contains("{\"s\":3,\"b\":2}"));
   }
 
+  @Test
   public void testMapOfSubclassFields() {
     Map<String, Base> map = new HashMap<>();
     map.put("base", new Base(1));
@@ -73,6 +79,7 @@ public class MoreSpecificTypeSerializationTest extends TestCase {
   /**
    * For parameterized type, Gson ignores the more-specific type and sticks to the declared type
    */
+  @Test
   public void testParameterizedSubclassFields() {
     ClassWithParameterizedBaseFields target = new ClassWithParameterizedBaseFields(
         new ParameterizedSub<>("one", "two"));
@@ -85,6 +92,7 @@ public class MoreSpecificTypeSerializationTest extends TestCase {
    * For parameterized type in a List, Gson ignores the more-specific type and sticks to
    * the declared type
    */
+  @Test
   public void testListOfParameterizedSubclassFields() {
     Collection<ParameterizedBase<String>> list = new ArrayList<>();
     list.add(new ParameterizedBase<>("one"));
@@ -100,6 +108,7 @@ public class MoreSpecificTypeSerializationTest extends TestCase {
    * For parameterized type in a map, Gson ignores the more-specific type and sticks to the
    * declared type
    */
+  @Test
   public void testMapOfParameterizedSubclassFields() {
     Map<String, ParameterizedBase<String>> map = new HashMap<>();
     map.put("base", new ParameterizedBase<>("one"));
diff --git a/gson/src/test/java/com/google/gson/functional/NamingPolicyTest.java b/gson/src/test/java/com/google/gson/functional/NamingPolicyTest.java
index ab76e649..67246bf7 100644
--- a/gson/src/test/java/com/google/gson/functional/NamingPolicyTest.java
+++ b/gson/src/test/java/com/google/gson/functional/NamingPolicyTest.java
@@ -15,6 +15,9 @@
  */
 package com.google.gson.functional;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
 import com.google.gson.FieldNamingPolicy;
 import com.google.gson.FieldNamingStrategy;
 import com.google.gson.Gson;
@@ -22,10 +25,9 @@ import com.google.gson.GsonBuilder;
 import com.google.gson.annotations.SerializedName;
 import com.google.gson.common.TestTypes.ClassWithSerializedNameFields;
 import com.google.gson.common.TestTypes.StringWrapper;
-
-import junit.framework.TestCase;
-
 import java.lang.reflect.Field;
+import org.junit.Before;
+import org.junit.Test;
 
 /**
  * Functional tests for naming policies.
@@ -33,15 +35,15 @@ import java.lang.reflect.Field;
  * @author Inderjeet Singh
  * @author Joel Leitch
  */
-public class NamingPolicyTest extends TestCase {
+public class NamingPolicyTest {
   private GsonBuilder builder;
 
-  @Override
-  protected void setUp() throws Exception {
-    super.setUp();
+  @Before
+  public void setUp() throws Exception {
     builder = new GsonBuilder();
   }
 
+  @Test
   public void testGsonWithNonDefaultFieldNamingPolicySerialization() {
     Gson gson = builder.setFieldNamingPolicy(FieldNamingPolicy.UPPER_CAMEL_CASE).create();
     StringWrapper target = new StringWrapper("blah");
@@ -49,6 +51,7 @@ public class NamingPolicyTest extends TestCase {
         + target.someConstantStringInstanceField + "\"}", gson.toJson(target));
   }
 
+  @Test
   public void testGsonWithNonDefaultFieldNamingPolicyDeserialiation() {
     Gson gson = builder.setFieldNamingPolicy(FieldNamingPolicy.UPPER_CAMEL_CASE).create();
     String target = "{\"SomeConstantStringInstanceField\":\"someValue\"}";
@@ -56,6 +59,7 @@ public class NamingPolicyTest extends TestCase {
     assertEquals("someValue", deserializedObject.someConstantStringInstanceField);
   }
 
+  @Test
   public void testGsonWithLowerCaseDashPolicySerialization() {
     Gson gson = builder.setFieldNamingPolicy(FieldNamingPolicy.LOWER_CASE_WITH_DASHES).create();
     StringWrapper target = new StringWrapper("blah");
@@ -63,6 +67,7 @@ public class NamingPolicyTest extends TestCase {
         + target.someConstantStringInstanceField + "\"}", gson.toJson(target));
   }
 
+  @Test
   public void testGsonWithLowerCaseDotPolicySerialization() {
     Gson gson = builder.setFieldNamingPolicy(FieldNamingPolicy.LOWER_CASE_WITH_DOTS).create();
     StringWrapper target = new StringWrapper("blah");
@@ -70,6 +75,7 @@ public class NamingPolicyTest extends TestCase {
           + target.someConstantStringInstanceField + "\"}", gson.toJson(target));
   }
 
+  @Test
   public void testGsonWithLowerCaseDotPolicyDeserialiation() {
     Gson gson = builder.setFieldNamingPolicy(FieldNamingPolicy.LOWER_CASE_WITH_DOTS).create();
     String target = "{\"some.constant.string.instance.field\":\"someValue\"}";
@@ -77,6 +83,7 @@ public class NamingPolicyTest extends TestCase {
     assertEquals("someValue", deserializedObject.someConstantStringInstanceField);
   }
 
+  @Test
   public void testGsonWithLowerCaseDashPolicyDeserialiation() {
     Gson gson = builder.setFieldNamingPolicy(FieldNamingPolicy.LOWER_CASE_WITH_DASHES).create();
     String target = "{\"some-constant-string-instance-field\":\"someValue\"}";
@@ -84,6 +91,7 @@ public class NamingPolicyTest extends TestCase {
     assertEquals("someValue", deserializedObject.someConstantStringInstanceField);
   }
 
+  @Test
   public void testGsonWithLowerCaseUnderscorePolicySerialization() {
     Gson gson = builder.setFieldNamingPolicy(FieldNamingPolicy.LOWER_CASE_WITH_UNDERSCORES)
         .create();
@@ -92,6 +100,7 @@ public class NamingPolicyTest extends TestCase {
         + target.someConstantStringInstanceField + "\"}", gson.toJson(target));
   }
 
+  @Test
   public void testGsonWithLowerCaseUnderscorePolicyDeserialiation() {
     Gson gson = builder.setFieldNamingPolicy(FieldNamingPolicy.LOWER_CASE_WITH_UNDERSCORES)
         .create();
@@ -100,6 +109,7 @@ public class NamingPolicyTest extends TestCase {
     assertEquals("someValue", deserializedObject.someConstantStringInstanceField);
   }
 
+  @Test
   public void testGsonWithSerializedNameFieldNamingPolicySerialization() {
     Gson gson = builder.create();
     ClassWithSerializedNameFields expected = new ClassWithSerializedNameFields(5, 6);
@@ -107,6 +117,7 @@ public class NamingPolicyTest extends TestCase {
     assertEquals(expected.getExpectedJson(), actual);
   }
 
+  @Test
   public void testGsonWithSerializedNameFieldNamingPolicyDeserialization() {
     Gson gson = builder.create();
     ClassWithSerializedNameFields expected = new ClassWithSerializedNameFields(5, 7);
@@ -115,6 +126,7 @@ public class NamingPolicyTest extends TestCase {
     assertEquals(expected.f, actual.f);
   }
 
+  @Test
   public void testGsonDuplicateNameUsingSerializedNameFieldNamingPolicySerialization() {
     Gson gson = builder.create();
     try {
@@ -122,9 +134,16 @@ public class NamingPolicyTest extends TestCase {
       gson.toJson(target);
       fail();
     } catch (IllegalArgumentException expected) {
+      assertEquals(
+          "Class com.google.gson.functional.NamingPolicyTest$ClassWithDuplicateFields declares multiple JSON fields named 'a';"
+          + " conflict is caused by fields com.google.gson.functional.NamingPolicyTest$ClassWithDuplicateFields#a and"
+          + " com.google.gson.functional.NamingPolicyTest$ClassWithDuplicateFields#b",
+          expected.getMessage()
+      );
     }
   }
 
+  @Test
   public void testGsonWithUpperCamelCaseSpacesPolicySerialiation() {
     Gson gson = builder.setFieldNamingPolicy(FieldNamingPolicy.UPPER_CAMEL_CASE_WITH_SPACES)
         .create();
@@ -133,6 +152,7 @@ public class NamingPolicyTest extends TestCase {
         + target.someConstantStringInstanceField + "\"}", gson.toJson(target));
   }
 
+  @Test
   public void testGsonWithUpperCamelCaseSpacesPolicyDeserialiation() {
     Gson gson = builder.setFieldNamingPolicy(FieldNamingPolicy.UPPER_CAMEL_CASE_WITH_SPACES)
         .create();
@@ -141,6 +161,7 @@ public class NamingPolicyTest extends TestCase {
     assertEquals("someValue", deserializedObject.someConstantStringInstanceField);
   }
 
+  @Test
   public void testGsonWithUpperCaseUnderscorePolicySerialization() {
     Gson gson = builder.setFieldNamingPolicy(FieldNamingPolicy.UPPER_CASE_WITH_UNDERSCORES)
         .create();
@@ -149,6 +170,7 @@ public class NamingPolicyTest extends TestCase {
         + target.someConstantStringInstanceField + "\"}", gson.toJson(target));
   }
 
+  @Test
   public void testGsonWithUpperCaseUnderscorePolicyDeserialiation() {
     Gson gson = builder.setFieldNamingPolicy(FieldNamingPolicy.UPPER_CASE_WITH_UNDERSCORES)
         .create();
@@ -157,6 +179,7 @@ public class NamingPolicyTest extends TestCase {
     assertEquals("someValue", deserializedObject.someConstantStringInstanceField);
   }
 
+  @Test
   public void testDeprecatedNamingStrategy() throws Exception {
     Gson gson = builder.setFieldNamingStrategy(new UpperCaseNamingStrategy()).create();
     ClassWithDuplicateFields target = new ClassWithDuplicateFields(10);
@@ -164,6 +187,7 @@ public class NamingPolicyTest extends TestCase {
     assertEquals("{\"A\":10}", actual);
   }
 
+  @Test
   public void testComplexFieldNameStrategy() throws Exception {
     Gson gson = new Gson();
     String json = gson.toJson(new ClassWithComplexFieldName(10));
@@ -175,6 +199,7 @@ public class NamingPolicyTest extends TestCase {
   }
 
   /** http://code.google.com/p/google-gson/issues/detail?id=349 */
+  @Test
   public void testAtSignInSerializedName() {
     assertEquals("{\"@foo\":\"bar\"}", new Gson().toJson(new AtName()));
   }
diff --git a/gson/src/test/java/com/google/gson/functional/NullObjectAndFieldTest.java b/gson/src/test/java/com/google/gson/functional/NullObjectAndFieldTest.java
index 49cb18a6..7c6e5769 100644
--- a/gson/src/test/java/com/google/gson/functional/NullObjectAndFieldTest.java
+++ b/gson/src/test/java/com/google/gson/functional/NullObjectAndFieldTest.java
@@ -16,22 +16,26 @@
 
 package com.google.gson.functional;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonDeserializer;
 import com.google.gson.JsonElement;
 import com.google.gson.JsonNull;
 import com.google.gson.JsonObject;
-import com.google.gson.JsonDeserializationContext;
-import com.google.gson.JsonDeserializer;
 import com.google.gson.JsonSerializationContext;
 import com.google.gson.JsonSerializer;
 import com.google.gson.common.TestTypes.BagOfPrimitives;
 import com.google.gson.common.TestTypes.ClassWithObjects;
-
-import junit.framework.TestCase;
-
 import java.lang.reflect.Type;
 import java.util.Collection;
+import org.junit.Before;
+import org.junit.Test;
 
 /**
  * Functional tests for the different cases for serializing (or ignoring) null fields and object.
@@ -39,15 +43,15 @@ import java.util.Collection;
  * @author Inderjeet Singh
  * @author Joel Leitch
  */
-public class NullObjectAndFieldTest extends TestCase {
+public class NullObjectAndFieldTest {
   private GsonBuilder gsonBuilder;
 
-  @Override
-  protected void setUp() throws Exception {
-    super.setUp();
+  @Before
+  public void setUp() throws Exception {
     gsonBuilder = new GsonBuilder().serializeNulls();
   }
 
+  @Test
   public void testTopLevelNullObjectSerialization() {
     Gson gson = gsonBuilder.create();
     String actual = gson.toJson(null);
@@ -57,12 +61,14 @@ public class NullObjectAndFieldTest extends TestCase {
     assertEquals("null", actual);
   }
 
+  @Test
   public void testTopLevelNullObjectDeserialization() throws Exception {
     Gson gson = gsonBuilder.create();
     String actual = gson.fromJson("null", String.class);
     assertNull(actual);
   }
 
+  @Test
   public void testExplicitSerializationOfNulls() {
     Gson gson = gsonBuilder.create();
     ClassWithObjects target = new ClassWithObjects(null);
@@ -71,12 +77,14 @@ public class NullObjectAndFieldTest extends TestCase {
     assertEquals(expected, actual);
   }
 
+  @Test
   public void testExplicitDeserializationOfNulls() throws Exception {
     Gson gson = gsonBuilder.create();
     ClassWithObjects target = gson.fromJson("{\"bag\":null}", ClassWithObjects.class);
     assertNull(target.bag);
   }
   
+  @Test
   public void testExplicitSerializationOfNullArrayMembers() {
     Gson gson = gsonBuilder.create();
     ClassWithMembers target = new ClassWithMembers();
@@ -87,6 +95,7 @@ public class NullObjectAndFieldTest extends TestCase {
   /** 
    * Added to verify http://code.google.com/p/google-gson/issues/detail?id=68
    */
+  @Test
   public void testNullWrappedPrimitiveMemberSerialization() {
     Gson gson = gsonBuilder.serializeNulls().create();
     ClassWithNullWrappedPrimitive target = new ClassWithNullWrappedPrimitive();
@@ -97,6 +106,7 @@ public class NullObjectAndFieldTest extends TestCase {
   /** 
    * Added to verify http://code.google.com/p/google-gson/issues/detail?id=68
    */
+  @Test
   public void testNullWrappedPrimitiveMemberDeserialization() {
     Gson gson = gsonBuilder.create();
     String json = "{\"value\":null}";
@@ -104,6 +114,7 @@ public class NullObjectAndFieldTest extends TestCase {
     assertNull(target.value);
   }
   
+  @Test
   public void testExplicitSerializationOfNullCollectionMembers() {
     Gson gson = gsonBuilder.create();
     ClassWithMembers target = new ClassWithMembers();
@@ -111,6 +122,7 @@ public class NullObjectAndFieldTest extends TestCase {
     assertTrue(json.contains("\"col\":null"));
   }
   
+  @Test
   public void testExplicitSerializationOfNullStringMembers() {
     Gson gson = gsonBuilder.create();
     ClassWithMembers target = new ClassWithMembers();
@@ -118,6 +130,7 @@ public class NullObjectAndFieldTest extends TestCase {
     assertTrue(json.contains("\"str\":null"));
   }
 
+  @Test
   public void testCustomSerializationOfNulls() {
     gsonBuilder.registerTypeAdapter(ClassWithObjects.class, new ClassWithObjectsSerializer());
     Gson gson = gsonBuilder.create();
@@ -127,6 +140,7 @@ public class NullObjectAndFieldTest extends TestCase {
     assertEquals(expected, actual);
   }
   
+  @Test
   public void testPrintPrintingObjectWithNulls() throws Exception {
     gsonBuilder = new GsonBuilder();
     Gson gson = gsonBuilder.create();
@@ -138,6 +152,7 @@ public class NullObjectAndFieldTest extends TestCase {
     assertTrue(result.contains("\"str\":null"));
   }
   
+  @Test
   public void testPrintPrintingArraysWithNulls() throws Exception {
     gsonBuilder = new GsonBuilder();
     Gson gson = gsonBuilder.create();
@@ -150,6 +165,7 @@ public class NullObjectAndFieldTest extends TestCase {
   }
 
   // test for issue 389
+  @Test
   public void testAbsentJsonElementsAreSetToNull() {
     Gson gson = new Gson();
     ClassWithInitializedMembers target =
@@ -200,6 +216,7 @@ public class NullObjectAndFieldTest extends TestCase {
     }
   }
 
+  @Test
   public void testExplicitNullSetsFieldToNullDuringDeserialization() {
     Gson gson = new Gson();
     String json = "{value:null}";
@@ -207,6 +224,7 @@ public class NullObjectAndFieldTest extends TestCase {
     assertNull(obj.value);
   }
 
+  @Test
   public void testCustomTypeAdapterPassesNullSerialization() {
     Gson gson = new GsonBuilder()
         .registerTypeAdapter(ObjectWithField.class, new JsonSerializer<ObjectWithField>() {
@@ -221,6 +239,7 @@ public class NullObjectAndFieldTest extends TestCase {
     assertFalse(json.contains("value1"));
   }
 
+  @Test
   public void testCustomTypeAdapterPassesNullDesrialization() {
     Gson gson = new GsonBuilder()
             .setLenient()
diff --git a/gson/src/test/java/com/google/gson/functional/ObjectTest.java b/gson/src/test/java/com/google/gson/functional/ObjectTest.java
index 9fd5dd50..9a39168c 100644
--- a/gson/src/test/java/com/google/gson/functional/ObjectTest.java
+++ b/gson/src/test/java/com/google/gson/functional/ObjectTest.java
@@ -16,6 +16,14 @@
 
 package com.google.gson.functional;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
 import com.google.gson.InstanceCreator;
@@ -45,7 +53,9 @@ import java.util.List;
 import java.util.Locale;
 import java.util.Map;
 import java.util.TimeZone;
-import junit.framework.TestCase;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
 
 /**
  * Functional tests for Json serialization and deserialization of regular classes.
@@ -53,14 +63,13 @@ import junit.framework.TestCase;
  * @author Inderjeet Singh
  * @author Joel Leitch
  */
-public class ObjectTest extends TestCase {
+public class ObjectTest {
   private Gson gson;
   private TimeZone oldTimeZone;
   private Locale oldLocale;
 
-  @Override
-  protected void setUp() throws Exception {
-    super.setUp();
+  @Before
+  public void setUp() throws Exception {
     gson = new Gson();
 
     oldTimeZone = TimeZone.getDefault();
@@ -69,13 +78,13 @@ public class ObjectTest extends TestCase {
     Locale.setDefault(Locale.US);
   }
 
-  @Override
-  protected void tearDown() throws Exception {
+  @After
+  public void tearDown() throws Exception {
     TimeZone.setDefault(oldTimeZone);
     Locale.setDefault(oldLocale);
-    super.tearDown();
   }
 
+  @Test
   public void testJsonInSingleQuotesDeserialization() {
     String json = "{'stringValue':'no message','intValue':10,'longValue':20}";
     BagOfPrimitives target = gson.fromJson(json, BagOfPrimitives.class);
@@ -84,6 +93,7 @@ public class ObjectTest extends TestCase {
     assertEquals(20, target.longValue);
   }
 
+  @Test
   public void testJsonInMixedQuotesDeserialization() {
     String json = "{\"stringValue\":'no message','intValue':10,'longValue':20}";
     BagOfPrimitives target = gson.fromJson(json, BagOfPrimitives.class);
@@ -92,11 +102,13 @@ public class ObjectTest extends TestCase {
     assertEquals(20, target.longValue);
   }
 
+  @Test
   public void testBagOfPrimitivesSerialization() throws Exception {
     BagOfPrimitives target = new BagOfPrimitives(10, 20, false, "stringValue");
     assertEquals(target.getExpectedJson(), gson.toJson(target));
   }
 
+  @Test
   public void testBagOfPrimitivesDeserialization() throws Exception {
     BagOfPrimitives src = new BagOfPrimitives(10, 20, false, "stringValue");
     String json = src.getExpectedJson();
@@ -104,11 +116,13 @@ public class ObjectTest extends TestCase {
     assertEquals(json, target.getExpectedJson());
   }
 
+  @Test
   public void testBagOfPrimitiveWrappersSerialization() throws Exception {
     BagOfPrimitiveWrappers target = new BagOfPrimitiveWrappers(10L, 20, false);
     assertEquals(target.getExpectedJson(), gson.toJson(target));
   }
 
+  @Test
   public void testBagOfPrimitiveWrappersDeserialization() throws Exception {
     BagOfPrimitiveWrappers target = new BagOfPrimitiveWrappers(10L, 20, false);
     String jsonString = target.getExpectedJson();
@@ -116,17 +130,20 @@ public class ObjectTest extends TestCase {
     assertEquals(jsonString, target.getExpectedJson());
   }
 
+  @Test
   public void testClassWithTransientFieldsSerialization() throws Exception {
     ClassWithTransientFields<Long> target = new ClassWithTransientFields<>(1L);
     assertEquals(target.getExpectedJson(), gson.toJson(target));
   }
 
+  @Test
   public void testClassWithTransientFieldsDeserialization() throws Exception {
     String json = "{\"longValue\":[1]}";
     ClassWithTransientFields<?> target = gson.fromJson(json, ClassWithTransientFields.class);
     assertEquals(json, target.getExpectedJson());
   }
 
+  @Test
   public void testClassWithTransientFieldsDeserializationTransientFieldsPassedInJsonAreIgnored()
       throws Exception {
     String json = "{\"transientLongValue\":1,\"longValue\":[1]}";
@@ -134,10 +151,12 @@ public class ObjectTest extends TestCase {
     assertFalse(target.transientLongValue != 1);
   }
 
+  @Test
   public void testClassWithNoFieldsSerialization() throws Exception {
     assertEquals("{}", gson.toJson(new ClassWithNoFields()));
   }
 
+  @Test
   public void testClassWithNoFieldsDeserialization() throws Exception {
     String json = "{}";
     ClassWithNoFields target = gson.fromJson(json, ClassWithNoFields.class);
@@ -145,12 +164,40 @@ public class ObjectTest extends TestCase {
     assertEquals(expected, target);
   }
 
+  private static class Subclass extends Superclass1 {
+  }
+  private static class Superclass1 extends Superclass2 {
+    @SuppressWarnings("unused")
+    String s;
+  }
+  private static class Superclass2 {
+    @SuppressWarnings("unused")
+    String s;
+  }
+
+  @Test
+  public void testClassWithDuplicateFields() {
+    try {
+      gson.getAdapter(Subclass.class);
+      fail();
+    } catch (IllegalArgumentException e) {
+      assertEquals(
+          "Class com.google.gson.functional.ObjectTest$Subclass declares multiple JSON fields named 's';"
+          + " conflict is caused by fields com.google.gson.functional.ObjectTest$Superclass1#s and"
+          + " com.google.gson.functional.ObjectTest$Superclass2#s",
+          e.getMessage()
+      );
+    }
+  }
+
+  @Test
   public void testNestedSerialization() throws Exception {
     Nested target = new Nested(new BagOfPrimitives(10, 20, false, "stringValue"),
        new BagOfPrimitives(30, 40, true, "stringValue"));
     assertEquals(target.getExpectedJson(), gson.toJson(target));
   }
 
+  @Test
   public void testNestedDeserialization() throws Exception {
     String json = "{\"primitive1\":{\"longValue\":10,\"intValue\":20,\"booleanValue\":false,"
         + "\"stringValue\":\"stringValue\"},\"primitive2\":{\"longValue\":30,\"intValue\":40,"
@@ -158,15 +205,18 @@ public class ObjectTest extends TestCase {
     Nested target = gson.fromJson(json, Nested.class);
     assertEquals(json, target.getExpectedJson());
   }
+  @Test
   public void testNullSerialization() throws Exception {
     assertEquals("null", gson.toJson(null));
   }
 
+  @Test
   public void testEmptyStringDeserialization() throws Exception {
     Object object = gson.fromJson("", Object.class);
     assertNull(object);
   }
 
+  @Test
   public void testTruncatedDeserialization() {
     try {
       gson.fromJson("[\"a\", \"b\",", new TypeToken<List<String>>() {}.getType());
@@ -175,17 +225,20 @@ public class ObjectTest extends TestCase {
     }
   }
 
+  @Test
   public void testNullDeserialization() throws Exception {
     String myNullObject = null;
     Object object = gson.fromJson(myNullObject, Object.class);
     assertNull(object);
   }
 
+  @Test
   public void testNullFieldsSerialization() throws Exception {
     Nested target = new Nested(new BagOfPrimitives(10, 20, false, "stringValue"), null);
     assertEquals(target.getExpectedJson(), gson.toJson(target));
   }
 
+  @Test
   public void testNullFieldsDeserialization() throws Exception {
     String json = "{\"primitive1\":{\"longValue\":10,\"intValue\":20,\"booleanValue\":false"
         + ",\"stringValue\":\"stringValue\"}}";
@@ -193,28 +246,33 @@ public class ObjectTest extends TestCase {
     assertEquals(json, target.getExpectedJson());
   }
 
+  @Test
   public void testArrayOfObjectsSerialization() throws Exception {
     ArrayOfObjects target = new ArrayOfObjects();
     assertEquals(target.getExpectedJson(), gson.toJson(target));
   }
 
+  @Test
   public void testArrayOfObjectsDeserialization() throws Exception {
     String json = new ArrayOfObjects().getExpectedJson();
     ArrayOfObjects target = gson.fromJson(json, ArrayOfObjects.class);
     assertEquals(json, target.getExpectedJson());
   }
 
+  @Test
   public void testArrayOfArraysSerialization() throws Exception {
     ArrayOfArrays target = new ArrayOfArrays();
     assertEquals(target.getExpectedJson(), gson.toJson(target));
   }
 
+  @Test
   public void testArrayOfArraysDeserialization() throws Exception {
     String json = new ArrayOfArrays().getExpectedJson();
     ArrayOfArrays target = gson.fromJson(json, ArrayOfArrays.class);
     assertEquals(json, target.getExpectedJson());
   }
 
+  @Test
   public void testArrayOfObjectsAsFields() throws Exception {
     ClassWithObjects classWithObjects = new ClassWithObjects();
     BagOfPrimitives bagOfPrimitives = new BagOfPrimitives();
@@ -234,6 +292,7 @@ public class ObjectTest extends TestCase {
   /**
    * Created in response to Issue 14: http://code.google.com/p/google-gson/issues/detail?id=14
    */
+  @Test
   public void testNullArraysDeserialization() throws Exception {
     String json = "{\"array\": null}";
     ClassWithArray target = gson.fromJson(json, ClassWithArray.class);
@@ -243,12 +302,14 @@ public class ObjectTest extends TestCase {
   /**
    * Created in response to Issue 14: http://code.google.com/p/google-gson/issues/detail?id=14
    */
+  @Test
   public void testNullObjectFieldsDeserialization() throws Exception {
     String json = "{\"bag\": null}";
     ClassWithObjects target = gson.fromJson(json, ClassWithObjects.class);
     assertNull(target.bag);
   }
 
+  @Test
   public void testEmptyCollectionInAnObjectDeserialization() throws Exception {
     String json = "{\"children\":[]}";
     ClassWithCollectionField target = gson.fromJson(json, ClassWithCollectionField.class);
@@ -260,6 +321,7 @@ public class ObjectTest extends TestCase {
     Collection<String> children = new ArrayList<>();
   }
 
+  @Test
   public void testPrimitiveArrayInAnObjectDeserialization() throws Exception {
     String json = "{\"longArray\":[0,1,2,3,4,5,6,7,8,9]}";
     PrimitiveArray target = gson.fromJson(json, PrimitiveArray.class);
@@ -269,29 +331,34 @@ public class ObjectTest extends TestCase {
   /**
    * Created in response to Issue 14: http://code.google.com/p/google-gson/issues/detail?id=14
    */
+  @Test
   public void testNullPrimitiveFieldsDeserialization() throws Exception {
     String json = "{\"longValue\":null}";
     BagOfPrimitives target = gson.fromJson(json, BagOfPrimitives.class);
     assertEquals(BagOfPrimitives.DEFAULT_VALUE, target.longValue);
   }
 
+  @Test
   public void testEmptyCollectionInAnObjectSerialization() throws Exception {
     ClassWithCollectionField target = new ClassWithCollectionField();
     assertEquals("{\"children\":[]}", gson.toJson(target));
   }
 
+  @Test
   public void testPrivateNoArgConstructorDeserialization() throws Exception {
     ClassWithPrivateNoArgsConstructor target =
       gson.fromJson("{\"a\":20}", ClassWithPrivateNoArgsConstructor.class);
     assertEquals(20, target.a);
   }
 
+  @Test
   public void testAnonymousLocalClassesSerialization() throws Exception {
     assertEquals("null", gson.toJson(new ClassWithNoFields() {
       // empty anonymous class
     }));
   }
 
+  @Test
   public void testAnonymousLocalClassesCustomSerialization() throws Exception {
     gson = new GsonBuilder()
         .registerTypeHierarchyAdapter(ClassWithNoFields.class,
@@ -307,6 +374,7 @@ public class ObjectTest extends TestCase {
     }));
   }
 
+  @Test
   public void testPrimitiveArrayFieldSerialization() {
     PrimitiveArray target = new PrimitiveArray(new long[] { 1L, 2L, 3L });
     assertEquals(target.getExpectedJson(), gson.toJson(target));
@@ -316,6 +384,7 @@ public class ObjectTest extends TestCase {
    * Tests that a class field with type Object can be serialized properly.
    * See issue 54
    */
+  @Test
   public void testClassWithObjectFieldSerialization() {
     ClassWithObjectField obj = new ClassWithObjectField();
     obj.member = "abc";
@@ -328,6 +397,7 @@ public class ObjectTest extends TestCase {
     Object member;
   }
 
+  @Test
   public void testInnerClassSerialization() {
     Parent p = new Parent();
     Parent.Child c = p.new Child();
@@ -336,6 +406,7 @@ public class ObjectTest extends TestCase {
     assertFalse(json.contains("value1"));
   }
 
+  @Test
   public void testInnerClassDeserialization() {
     final Parent p = new Parent();
     Gson gson = new GsonBuilder().registerTypeAdapter(
@@ -404,6 +475,7 @@ public class ObjectTest extends TestCase {
   /**
    * In response to Issue 41 http://code.google.com/p/google-gson/issues/detail?id=41
    */
+  @Test
   public void testObjectFieldNamesWithoutQuotesDeserialization() {
     String json = "{longValue:1,'booleanValue':true,\"stringValue\":'bar'}";
     BagOfPrimitives bag = gson.fromJson(json, BagOfPrimitives.class);
@@ -412,6 +484,7 @@ public class ObjectTest extends TestCase {
     assertEquals("bar", bag.stringValue);
   }
 
+  @Test
   public void testStringFieldWithNumberValueDeserialization() {
     String json = "{\"stringValue\":1}";
     BagOfPrimitives bag = gson.fromJson(json, BagOfPrimitives.class);
@@ -429,6 +502,7 @@ public class ObjectTest extends TestCase {
   /**
    * Created to reproduce issue 140
    */
+  @Test
   public void testStringFieldWithEmptyValueSerialization() {
     ClassWithEmptyStringFields target = new ClassWithEmptyStringFields();
     target.a = "5794749";
@@ -441,6 +515,7 @@ public class ObjectTest extends TestCase {
   /**
    * Created to reproduce issue 140
    */
+  @Test
   public void testStringFieldWithEmptyValueDeserialization() {
     String json = "{a:\"5794749\",b:\"\",c:\"\"}";
     ClassWithEmptyStringFields target = gson.fromJson(json, ClassWithEmptyStringFields.class);
@@ -455,6 +530,7 @@ public class ObjectTest extends TestCase {
     String c = "";
   }
 
+  @Test
   public void testJsonObjectSerialization() {
     Gson gson = new GsonBuilder().serializeNulls().create();
     JsonObject obj = new JsonObject();
@@ -465,6 +541,7 @@ public class ObjectTest extends TestCase {
   /**
    * Test for issue 215.
    */
+  @Test
   public void testSingletonLists() {
     Gson gson = new Gson();
     Product product = new Product();
@@ -494,6 +571,7 @@ public class ObjectTest extends TestCase {
   }
 
   // http://code.google.com/p/google-gson/issues/detail?id=270
+  @Test
   public void testDateAsMapObjectField() {
     HasObjectMap a = new HasObjectMap();
     a.map.put("date", new Date(0));
@@ -514,6 +592,7 @@ public class ObjectTest extends TestCase {
    * <p>Important: It is not documented that this is officially supported; this
    * test just checks the current behavior.
    */
+  @Test
   public void testStaticFieldSerialization() {
     // By default Gson should ignore static fields
     assertEquals("{}", gson.toJson(new ClassWithStaticField()));
@@ -536,6 +615,7 @@ public class ObjectTest extends TestCase {
    * <p>Important: It is not documented that this is officially supported; this
    * test just checks the current behavior.
    */
+  @Test
   public void testStaticFieldDeserialization() {
     // By default Gson should ignore static fields
     gson.fromJson("{\"s\":\"custom\"}", ClassWithStaticField.class);
@@ -572,6 +652,7 @@ public class ObjectTest extends TestCase {
     static final String s = "initial";
   }
 
+  @Test
   public void testThrowingDefaultConstructor() {
     try {
       gson.fromJson("{}", ClassWithThrowingConstructor.class);
diff --git a/gson/src/test/java/com/google/gson/functional/PrettyPrintingTest.java b/gson/src/test/java/com/google/gson/functional/PrettyPrintingTest.java
index 58827b41..dc029f97 100644
--- a/gson/src/test/java/com/google/gson/functional/PrettyPrintingTest.java
+++ b/gson/src/test/java/com/google/gson/functional/PrettyPrintingTest.java
@@ -15,20 +15,22 @@
  */
 package com.google.gson.functional;
 
-import java.lang.reflect.Type;
-import java.util.Arrays;
-import java.util.LinkedHashMap;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Map;
-
-import junit.framework.TestCase;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
 
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
 import com.google.gson.common.TestTypes.ArrayOfObjects;
 import com.google.gson.common.TestTypes.BagOfPrimitives;
 import com.google.gson.reflect.TypeToken;
+import java.lang.reflect.Type;
+import java.util.Arrays;
+import java.util.LinkedHashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import org.junit.Before;
+import org.junit.Test;
 
 /**
  * Functional tests for pretty printing option.
@@ -36,18 +38,18 @@ import com.google.gson.reflect.TypeToken;
  * @author Inderjeet Singh
  * @author Joel Leitch
  */
-public class PrettyPrintingTest extends TestCase {
+public class PrettyPrintingTest {
 
   private static final boolean DEBUG = false;
 
   private Gson gson;
 
-  @Override
-  protected void setUp() throws Exception {
-    super.setUp();
+  @Before
+  public void setUp() throws Exception {
     gson = new GsonBuilder().setPrettyPrinting().create();
   }
 
+  @Test
   public void testPrettyPrintList() {
     BagOfPrimitives b = new BagOfPrimitives();
     List<BagOfPrimitives> listOfB = new LinkedList<>();
@@ -59,18 +61,21 @@ public class PrettyPrintingTest extends TestCase {
     print(json);
   }
 
+  @Test
   public void testPrettyPrintArrayOfObjects() {
     ArrayOfObjects target = new ArrayOfObjects();
     String json = gson.toJson(target);
     print(json);
   }
 
+  @Test
   public void testPrettyPrintArrayOfPrimitives() {
     int[] ints = new int[] { 1, 2, 3, 4, 5 };
     String json = gson.toJson(ints);
     assertEquals("[\n  1,\n  2,\n  3,\n  4,\n  5\n]", json);
   }
 
+  @Test
   public void testPrettyPrintArrayOfPrimitiveArrays() {
     int[][] ints = new int[][] { { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7, 8 },
         { 9, 0 }, { 10 } };
@@ -79,6 +84,7 @@ public class PrettyPrintingTest extends TestCase {
         + "\n  [\n    7,\n    8\n  ],\n  [\n    9,\n    0\n  ],\n  [\n    10\n  ]\n]", json);
   }
 
+  @Test
   public void testPrettyPrintListOfPrimitiveArrays() {
     List<Integer[]> list = Arrays.asList(new Integer[][] { { 1, 2 }, { 3, 4 },
         { 5, 6 }, { 7, 8 }, { 9, 0 }, { 10 } });
@@ -87,6 +93,7 @@ public class PrettyPrintingTest extends TestCase {
         + "\n  [\n    7,\n    8\n  ],\n  [\n    9,\n    0\n  ],\n  [\n    10\n  ]\n]", json);
   }
   
+  @Test
   public void testMap() {
     Map<String, Integer> map = new LinkedHashMap<>();
     map.put("abc", 1);
@@ -96,6 +103,7 @@ public class PrettyPrintingTest extends TestCase {
   }
 
   // In response to bug 153
+  @Test
   public void testEmptyMapField() {
     ClassWithMap obj = new ClassWithMap();
     obj.map = new LinkedHashMap<>();
@@ -109,6 +117,7 @@ public class PrettyPrintingTest extends TestCase {
     int value = 2;
   }
 
+  @Test
   public void testMultipleArrays() {
     int[][][] ints = new int[][][] { { { 1 }, { 2 } } };
     String json = gson.toJson(ints);
diff --git a/gson/src/test/java/com/google/gson/functional/PrimitiveCharacterTest.java b/gson/src/test/java/com/google/gson/functional/PrimitiveCharacterTest.java
index 2a7e1582..2f2891ac 100644
--- a/gson/src/test/java/com/google/gson/functional/PrimitiveCharacterTest.java
+++ b/gson/src/test/java/com/google/gson/functional/PrimitiveCharacterTest.java
@@ -16,8 +16,11 @@
 
 package com.google.gson.functional;
 
-import com.google.gson.*;
-import junit.framework.TestCase;
+import static org.junit.Assert.assertEquals;
+
+import com.google.gson.Gson;
+import org.junit.Before;
+import org.junit.Test;
 
 /**
  * Functional tests for Java Character values.
@@ -25,21 +28,22 @@ import junit.framework.TestCase;
  * @author Inderjeet Singh
  * @author Joel Leitch
  */
-public class PrimitiveCharacterTest extends TestCase {
+public class PrimitiveCharacterTest {
   private Gson gson;
 
-  @Override
-  protected void setUp() throws Exception {
-    super.setUp();
+  @Before
+  public void setUp() throws Exception {
     gson = new Gson();
   }
 
+  @Test
   public void testPrimitiveCharacterAutoboxedSerialization() {
     assertEquals("\"A\"", gson.toJson('A'));
     assertEquals("\"A\"", gson.toJson('A', char.class));
     assertEquals("\"A\"", gson.toJson('A', Character.class));
   }
 
+  @Test
   public void testPrimitiveCharacterAutoboxedDeserialization() {
     char expected = 'a';
     char actual = gson.fromJson("a", char.class);
diff --git a/gson/src/test/java/com/google/gson/functional/PrimitiveTest.java b/gson/src/test/java/com/google/gson/functional/PrimitiveTest.java
index 13716346..3adc01ca 100644
--- a/gson/src/test/java/com/google/gson/functional/PrimitiveTest.java
+++ b/gson/src/test/java/com/google/gson/functional/PrimitiveTest.java
@@ -17,6 +17,10 @@
 package com.google.gson.functional;
 
 import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
 
 import com.google.gson.*;
 import com.google.gson.internal.LazilyParsedNumber;
@@ -27,7 +31,8 @@ import java.math.BigDecimal;
 import java.math.BigInteger;
 import java.util.Arrays;
 import java.util.List;
-import junit.framework.TestCase;
+import org.junit.Before;
+import org.junit.Test;
 
 /**
  * Functional tests for Json primitive values: integers, and floating point numbers.
@@ -35,19 +40,20 @@ import junit.framework.TestCase;
  * @author Inderjeet Singh
  * @author Joel Leitch
  */
-public class PrimitiveTest extends TestCase {
+public class PrimitiveTest {
   private Gson gson;
 
-  @Override
-  protected void setUp() throws Exception {
-    super.setUp();
+  @Before
+  public void setUp() throws Exception {
     gson = new Gson();
   }
 
+  @Test
   public void testPrimitiveIntegerAutoboxedSerialization() {
     assertEquals("1", gson.toJson(1));
   }
 
+  @Test
   public void testPrimitiveIntegerAutoboxedDeserialization() {
     int expected = 1;
     int actual = gson.fromJson("1", int.class);
@@ -57,6 +63,7 @@ public class PrimitiveTest extends TestCase {
     assertEquals(expected, actual);
   }
 
+  @Test
   public void testByteSerialization() {
     assertEquals("1", gson.toJson(1, byte.class));
     assertEquals("1", gson.toJson(1, Byte.class));
@@ -67,6 +74,7 @@ public class PrimitiveTest extends TestCase {
     assertEquals("1", gson.toJson(1.5, Byte.class));
   }
 
+  @Test
   public void testByteDeserialization() {
     Byte boxed = gson.fromJson("1", Byte.class);
     assertEquals(1, (byte)boxed);
@@ -77,6 +85,7 @@ public class PrimitiveTest extends TestCase {
     assertArrayEquals(new byte[] {-128, 0, 127, -1}, bytes);
   }
 
+  @Test
   public void testByteDeserializationLossy() {
     try {
       gson.fromJson("-129", byte.class);
@@ -100,6 +109,7 @@ public class PrimitiveTest extends TestCase {
     }
   }
 
+  @Test
   public void testShortSerialization() {
     assertEquals("1", gson.toJson(1, short.class));
     assertEquals("1", gson.toJson(1, Short.class));
@@ -112,6 +122,7 @@ public class PrimitiveTest extends TestCase {
     assertEquals("1", gson.toJson(1.5, Short.class));
   }
 
+  @Test
   public void testShortDeserialization() {
     Short boxed = gson.fromJson("1", Short.class);
     assertEquals(1, (short)boxed);
@@ -122,6 +133,7 @@ public class PrimitiveTest extends TestCase {
     assertArrayEquals(new short[] {-32768, 0, 32767, -1}, shorts);
   }
 
+  @Test
   public void testShortDeserializationLossy() {
     try {
       gson.fromJson("-32769", short.class);
@@ -145,6 +157,7 @@ public class PrimitiveTest extends TestCase {
     }
   }
 
+  @Test
   public void testIntSerialization() {
     assertEquals("1", gson.toJson(1, int.class));
     assertEquals("1", gson.toJson(1, Integer.class));
@@ -157,6 +170,7 @@ public class PrimitiveTest extends TestCase {
     assertEquals("1", gson.toJson(1.5, Integer.class));
   }
 
+  @Test
   public void testLongSerialization() {
     assertEquals("1", gson.toJson(1L, long.class));
     assertEquals("1", gson.toJson(1L, Long.class));
@@ -168,6 +182,7 @@ public class PrimitiveTest extends TestCase {
     assertEquals("1", gson.toJson(1.5, Long.class));
   }
 
+  @Test
   public void testFloatSerialization() {
     assertEquals("1.5", gson.toJson(1.5f, float.class));
     assertEquals("1.5", gson.toJson(1.5f, Float.class));
@@ -182,6 +197,7 @@ public class PrimitiveTest extends TestCase {
     assertEquals("Infinity", gson.toJson(Double.MAX_VALUE, Float.class));
   }
 
+  @Test
   public void testDoubleSerialization() {
     assertEquals("1.5", gson.toJson(1.5, double.class));
     assertEquals("1.5", gson.toJson(1.5, Double.class));
@@ -193,6 +209,7 @@ public class PrimitiveTest extends TestCase {
     assertEquals(Double.toString(Long.MAX_VALUE - 10L), gson.toJson(Long.MAX_VALUE - 10L, Double.class));
   }
 
+  @Test
   public void testPrimitiveIntegerAutoboxedInASingleElementArraySerialization() {
     int target[] = {-9332};
     assertEquals("[-9332]", gson.toJson(target));
@@ -200,22 +217,26 @@ public class PrimitiveTest extends TestCase {
     assertEquals("[-9332]", gson.toJson(target, Integer[].class));
   }
 
+  @Test
   public void testReallyLongValuesSerialization() {
     long value = 333961828784581L;
     assertEquals("333961828784581", gson.toJson(value));
   }
 
+  @Test
   public void testReallyLongValuesDeserialization() {
     String json = "333961828784581";
     long value = gson.fromJson(json, Long.class);
     assertEquals(333961828784581L, value);
   }
 
+  @Test
   public void testPrimitiveLongAutoboxedSerialization() {
     assertEquals("1", gson.toJson(1L, long.class));
     assertEquals("1", gson.toJson(1L, Long.class));
   }
 
+  @Test
   public void testPrimitiveLongAutoboxedDeserialization() {
     long expected = 1L;
     long actual = gson.fromJson("1", long.class);
@@ -225,6 +246,7 @@ public class PrimitiveTest extends TestCase {
     assertEquals(expected, actual);
   }
 
+  @Test
   public void testPrimitiveLongAutoboxedInASingleElementArraySerialization() {
     long[] target = {-23L};
     assertEquals("[-23]", gson.toJson(target));
@@ -232,11 +254,13 @@ public class PrimitiveTest extends TestCase {
     assertEquals("[-23]", gson.toJson(target, Long[].class));
   }
 
+  @Test
   public void testPrimitiveBooleanAutoboxedSerialization() {
     assertEquals("true", gson.toJson(true));
     assertEquals("false", gson.toJson(false));
   }
 
+  @Test
   public void testBooleanDeserialization() {
     boolean value = gson.fromJson("false", boolean.class);
     assertEquals(false, value);
@@ -244,6 +268,7 @@ public class PrimitiveTest extends TestCase {
     assertEquals(true, value);
   }
 
+  @Test
   public void testPrimitiveBooleanAutoboxedInASingleElementArraySerialization() {
     boolean target[] = {false};
     assertEquals("[false]", gson.toJson(target));
@@ -251,6 +276,7 @@ public class PrimitiveTest extends TestCase {
     assertEquals("[false]", gson.toJson(target, Boolean[].class));
   }
 
+  @Test
   public void testNumberSerialization() {
     Number expected = 1L;
     String json = gson.toJson(expected);
@@ -260,6 +286,7 @@ public class PrimitiveTest extends TestCase {
     assertEquals(expected.toString(), json);
   }
 
+  @Test
   public void testNumberDeserialization() {
     String json = "1";
     Number expected = Integer.valueOf(json);
@@ -276,24 +303,28 @@ public class PrimitiveTest extends TestCase {
     assertEquals(1L, actual.longValue());
   }
 
+  @Test
   public void testNumberAsStringDeserialization() {
     Number value = gson.fromJson("\"18\"", Number.class);
     assertEquals(18, value.intValue());
   }
 
+  @Test
   public void testPrimitiveDoubleAutoboxedSerialization() {
     assertEquals("-122.08234335", gson.toJson(-122.08234335D));
     assertEquals("122.08112002", gson.toJson(122.08112002D));
   }
 
+  @Test
   public void testPrimitiveDoubleAutoboxedDeserialization() {
     double actual = gson.fromJson("-122.08858585", double.class);
-    assertEquals(-122.08858585D, actual);
+    assertEquals(-122.08858585D, actual, 0);
 
     actual = gson.fromJson("122.023900008000", Double.class);
-    assertEquals(122.023900008D, actual);
+    assertEquals(122.023900008D, actual, 0);
   }
 
+  @Test
   public void testPrimitiveDoubleAutoboxedInASingleElementArraySerialization() {
     double[] target = {-122.08D};
     assertEquals("[-122.08]", gson.toJson(target));
@@ -301,6 +332,7 @@ public class PrimitiveTest extends TestCase {
     assertEquals("[-122.08]", gson.toJson(target, Double[].class));
   }
 
+  @Test
   public void testDoubleAsStringRepresentationDeserialization() {
     String doubleValue = "1.0043E+5";
     Double expected = Double.valueOf(doubleValue);
@@ -308,9 +340,10 @@ public class PrimitiveTest extends TestCase {
     assertEquals(expected, actual);
 
     double actual1 = gson.fromJson(doubleValue, double.class);
-    assertEquals(expected.doubleValue(), actual1);
+    assertEquals(expected, actual1, 0);
   }
 
+  @Test
   public void testDoubleNoFractAsStringRepresentationDeserialization() {
     String doubleValue = "1E+5";
     Double expected = Double.valueOf(doubleValue);
@@ -318,22 +351,24 @@ public class PrimitiveTest extends TestCase {
     assertEquals(expected, actual);
 
     double actual1 = gson.fromJson(doubleValue, double.class);
-    assertEquals(expected.doubleValue(), actual1);
+    assertEquals(expected, actual1, 0);
   }
 
+  @Test
   public void testDoubleArrayDeserialization() {
       String json = "[0.0, 0.004761904761904762, 3.4013606962703525E-4, 7.936508173034305E-4,"
               + "0.0011904761904761906, 0.0]";
       double[] values = gson.fromJson(json, double[].class);
-      assertEquals(6, values.length);
-      assertEquals(0.0, values[0]);
-      assertEquals(0.004761904761904762, values[1]);
-      assertEquals(3.4013606962703525E-4, values[2]);
-      assertEquals(7.936508173034305E-4, values[3]);
-      assertEquals(0.0011904761904761906, values[4]);
-      assertEquals(0.0, values[5]);
+      assertEquals(6, values.length, 0);
+      assertEquals(0.0, values[0], 0);
+      assertEquals(0.004761904761904762, values[1], 0);
+      assertEquals(3.4013606962703525E-4, values[2], 0);
+      assertEquals(7.936508173034305E-4, values[3], 0);
+      assertEquals(0.0011904761904761906, values[4], 0);
+      assertEquals(0.0, values[5], 0);
   }
 
+  @Test
   public void testLargeDoubleDeserialization() {
     String doubleValue = "1.234567899E8";
     Double expected = Double.valueOf(doubleValue);
@@ -341,21 +376,24 @@ public class PrimitiveTest extends TestCase {
     assertEquals(expected, actual);
 
     double actual1 = gson.fromJson(doubleValue, double.class);
-    assertEquals(expected.doubleValue(), actual1);
+    assertEquals(expected, actual1, 0);
   }
 
+  @Test
   public void testBigDecimalSerialization() {
     BigDecimal target = new BigDecimal("-122.0e-21");
     String json = gson.toJson(target);
     assertEquals(target, new BigDecimal(json));
   }
 
+  @Test
   public void testBigDecimalDeserialization() {
     BigDecimal target = new BigDecimal("-122.0e-21");
     String json = "-122.0e-21";
     assertEquals(target, gson.fromJson(json, BigDecimal.class));
   }
 
+  @Test
   public void testBigDecimalInASingleElementArraySerialization() {
     BigDecimal[] target = {new BigDecimal("-122.08e-21")};
     String json = gson.toJson(target);
@@ -367,18 +405,21 @@ public class PrimitiveTest extends TestCase {
     assertEquals(target[0], new BigDecimal(actual));
   }
 
+  @Test
   public void testSmallValueForBigDecimalSerialization() {
     BigDecimal target = new BigDecimal("1.55");
     String actual = gson.toJson(target);
     assertEquals(target.toString(), actual);
   }
 
+  @Test
   public void testSmallValueForBigDecimalDeserialization() {
     BigDecimal expected = new BigDecimal("1.55");
     BigDecimal actual = gson.fromJson("1.55", BigDecimal.class);
     assertEquals(expected, actual);
   }
 
+  @Test
   public void testBigDecimalPreservePrecisionSerialization() {
     String expectedValue = "1.000";
     BigDecimal obj = new BigDecimal(expectedValue);
@@ -387,6 +428,7 @@ public class PrimitiveTest extends TestCase {
     assertEquals(expectedValue, actualValue);
   }
 
+  @Test
   public void testBigDecimalPreservePrecisionDeserialization() {
     String json = "1.000";
     BigDecimal expected = new BigDecimal(json);
@@ -395,6 +437,7 @@ public class PrimitiveTest extends TestCase {
     assertEquals(expected, actual);
   }
 
+  @Test
   public void testBigDecimalAsStringRepresentationDeserialization() {
     String doubleValue = "0.05E+5";
     BigDecimal expected = new BigDecimal(doubleValue);
@@ -402,6 +445,7 @@ public class PrimitiveTest extends TestCase {
     assertEquals(expected, actual);
   }
 
+  @Test
   public void testBigDecimalNoFractAsStringRepresentationDeserialization() {
     String doubleValue = "5E+5";
     BigDecimal expected = new BigDecimal(doubleValue);
@@ -409,17 +453,20 @@ public class PrimitiveTest extends TestCase {
     assertEquals(expected, actual);
   }
 
+  @Test
   public void testBigIntegerSerialization() {
     BigInteger target = new BigInteger("12121211243123245845384534687435634558945453489543985435");
     assertEquals(target.toString(), gson.toJson(target));
   }
 
+  @Test
   public void testBigIntegerDeserialization() {
     String json = "12121211243123245845384534687435634558945453489543985435";
     BigInteger target = new BigInteger(json);
     assertEquals(target, gson.fromJson(json, BigInteger.class));
   }
 
+  @Test
   public void testBigIntegerInASingleElementArraySerialization() {
     BigInteger[] target = {new BigInteger("1212121243434324323254365345367456456456465464564564")};
     String json = gson.toJson(target);
@@ -431,18 +478,21 @@ public class PrimitiveTest extends TestCase {
     assertEquals(target[0], new BigInteger(actual));
   }
 
+  @Test
   public void testSmallValueForBigIntegerSerialization() {
     BigInteger target = new BigInteger("15");
     String actual = gson.toJson(target);
     assertEquals(target.toString(), actual);
   }
 
+  @Test
   public void testSmallValueForBigIntegerDeserialization() {
     BigInteger expected = new BigInteger("15");
     BigInteger actual = gson.fromJson("15", BigInteger.class);
     assertEquals(expected, actual);
   }
 
+  @Test
   public void testBadValueForBigIntegerDeserialization() {
     try {
       gson.fromJson("15.099", BigInteger.class);
@@ -450,18 +500,21 @@ public class PrimitiveTest extends TestCase {
     } catch (JsonSyntaxException expected) { }
   }
 
+  @Test
   public void testLazilyParsedNumberSerialization() {
     LazilyParsedNumber target = new LazilyParsedNumber("1.5");
     String actual = gson.toJson(target);
     assertEquals("1.5", actual);
   }
 
+  @Test
   public void testLazilyParsedNumberDeserialization() {
     LazilyParsedNumber expected = new LazilyParsedNumber("1.5");
     LazilyParsedNumber actual = gson.fromJson("1.5", LazilyParsedNumber.class);
     assertEquals(expected, actual);
   }
 
+  @Test
   public void testMoreSpecificSerialization() {
     Gson gson = new Gson();
     String expected = "This is a string";
@@ -476,6 +529,7 @@ public class PrimitiveTest extends TestCase {
     return json.substring(json.indexOf('[') + 1, json.indexOf(']'));
   }
 
+  @Test
   public void testDoubleNaNSerializationNotSupportedByDefault() {
     try {
       double nan = Double.NaN;
@@ -490,6 +544,7 @@ public class PrimitiveTest extends TestCase {
     }
   }
 
+  @Test
   public void testDoubleNaNSerialization() {
     Gson gson = new GsonBuilder().setLenient().serializeSpecialFloatingPointValues().create();
     double nan = Double.NaN;
@@ -497,11 +552,13 @@ public class PrimitiveTest extends TestCase {
     assertEquals("NaN", gson.toJson(Double.NaN));
   }
 
+  @Test
   public void testDoubleNaNDeserialization() {
     assertTrue(Double.isNaN(gson.fromJson("NaN", Double.class)));
     assertTrue(Double.isNaN(gson.fromJson("NaN", double.class)));
   }
 
+  @Test
   public void testFloatNaNSerializationNotSupportedByDefault() {
     try {
       float nan = Float.NaN;
@@ -516,6 +573,7 @@ public class PrimitiveTest extends TestCase {
     }
   }
 
+  @Test
   public void testFloatNaNSerialization() {
     Gson gson = new GsonBuilder().setLenient().serializeSpecialFloatingPointValues().create();
     float nan = Float.NaN;
@@ -523,11 +581,13 @@ public class PrimitiveTest extends TestCase {
     assertEquals("NaN", gson.toJson(Float.NaN));
   }
 
+  @Test
   public void testFloatNaNDeserialization() {
     assertTrue(Float.isNaN(gson.fromJson("NaN", Float.class)));
     assertTrue(Float.isNaN(gson.fromJson("NaN", float.class)));
   }
 
+  @Test
   public void testBigDecimalNaNDeserializationNotSupported() {
     try {
       gson.fromJson("NaN", BigDecimal.class);
@@ -536,6 +596,7 @@ public class PrimitiveTest extends TestCase {
     }
   }
 
+  @Test
   public void testDoubleInfinitySerializationNotSupportedByDefault() {
     try {
       double infinity = Double.POSITIVE_INFINITY;
@@ -550,6 +611,7 @@ public class PrimitiveTest extends TestCase {
     }
   }
 
+  @Test
   public void testDoubleInfinitySerialization() {
     Gson gson = new GsonBuilder().setLenient().serializeSpecialFloatingPointValues().create();
     double infinity = Double.POSITIVE_INFINITY;
@@ -557,11 +619,13 @@ public class PrimitiveTest extends TestCase {
     assertEquals("Infinity", gson.toJson(Double.POSITIVE_INFINITY));
   }
 
+  @Test
   public void testDoubleInfinityDeserialization() {
     assertTrue(Double.isInfinite(gson.fromJson("Infinity", Double.class)));
     assertTrue(Double.isInfinite(gson.fromJson("Infinity", double.class)));
   }
 
+  @Test
   public void testFloatInfinitySerializationNotSupportedByDefault() {
     try {
       float infinity = Float.POSITIVE_INFINITY;
@@ -576,6 +640,7 @@ public class PrimitiveTest extends TestCase {
     }
   }
 
+  @Test
   public void testFloatInfinitySerialization() {
     Gson gson = new GsonBuilder().setLenient().serializeSpecialFloatingPointValues().create();
     float infinity = Float.POSITIVE_INFINITY;
@@ -583,11 +648,13 @@ public class PrimitiveTest extends TestCase {
     assertEquals("Infinity", gson.toJson(Float.POSITIVE_INFINITY));
   }
 
+  @Test
   public void testFloatInfinityDeserialization() {
     assertTrue(Float.isInfinite(gson.fromJson("Infinity", Float.class)));
     assertTrue(Float.isInfinite(gson.fromJson("Infinity", float.class)));
   }
 
+  @Test
   public void testBigDecimalInfinityDeserializationNotSupported() {
     try {
       gson.fromJson("Infinity", BigDecimal.class);
@@ -596,6 +663,7 @@ public class PrimitiveTest extends TestCase {
     }
   }
 
+  @Test
   public void testNegativeInfinitySerializationNotSupportedByDefault() {
     try {
       double negativeInfinity = Double.NEGATIVE_INFINITY;
@@ -610,6 +678,7 @@ public class PrimitiveTest extends TestCase {
     }
   }
 
+  @Test
   public void testNegativeInfinitySerialization() {
     Gson gson = new GsonBuilder().setLenient().serializeSpecialFloatingPointValues().create();
     double negativeInfinity = Double.NEGATIVE_INFINITY;
@@ -617,11 +686,13 @@ public class PrimitiveTest extends TestCase {
     assertEquals("-Infinity", gson.toJson(Double.NEGATIVE_INFINITY));
   }
 
+  @Test
   public void testNegativeInfinityDeserialization() {
     assertTrue(Double.isInfinite(gson.fromJson("-Infinity", double.class)));
     assertTrue(Double.isInfinite(gson.fromJson("-Infinity", Double.class)));
   }
 
+  @Test
   public void testNegativeInfinityFloatSerializationNotSupportedByDefault() {
     try {
       float negativeInfinity = Float.NEGATIVE_INFINITY;
@@ -636,6 +707,7 @@ public class PrimitiveTest extends TestCase {
     }
   }
 
+  @Test
   public void testNegativeInfinityFloatSerialization() {
     Gson gson = new GsonBuilder().setLenient().serializeSpecialFloatingPointValues().create();
     float negativeInfinity = Float.NEGATIVE_INFINITY;
@@ -643,11 +715,13 @@ public class PrimitiveTest extends TestCase {
     assertEquals("-Infinity", gson.toJson(Float.NEGATIVE_INFINITY));
   }
 
+  @Test
   public void testNegativeInfinityFloatDeserialization() {
     assertTrue(Float.isInfinite(gson.fromJson("-Infinity", float.class)));
     assertTrue(Float.isInfinite(gson.fromJson("-Infinity", Float.class)));
   }
 
+  @Test
   public void testBigDecimalNegativeInfinityDeserializationNotSupported() {
     try {
       gson.fromJson("-Infinity", BigDecimal.class);
@@ -656,6 +730,7 @@ public class PrimitiveTest extends TestCase {
     }
   }
 
+  @Test
   public void testLongAsStringSerialization() throws Exception {
     gson = new GsonBuilder().setLongSerializationPolicy(LongSerializationPolicy.STRING).create();
     String result = gson.toJson(15L);
@@ -666,6 +741,7 @@ public class PrimitiveTest extends TestCase {
     assertEquals("2", result);
   }
 
+  @Test
   public void testLongAsStringDeserialization() throws Exception {
     long value = gson.fromJson("\"15\"", long.class);
     assertEquals(15, value);
@@ -675,6 +751,7 @@ public class PrimitiveTest extends TestCase {
     assertEquals(25, value);
   }
 
+  @Test
   public void testQuotedStringSerializationAndDeserialization() throws Exception {
     String value = "String Blah Blah Blah...1, 2, 3";
     String serializedForm = gson.toJson(value);
@@ -684,6 +761,7 @@ public class PrimitiveTest extends TestCase {
     assertEquals(value, actual);
   }
 
+  @Test
   public void testUnquotedStringDeserializationFails() throws Exception {
     assertEquals("UnquotedSingleWord", gson.fromJson("UnquotedSingleWord", String.class));
 
@@ -694,6 +772,7 @@ public class PrimitiveTest extends TestCase {
     } catch (JsonSyntaxException expected) { }
   }
 
+  @Test
   public void testHtmlCharacterSerialization() throws Exception {
     String target = "<script>var a = 12;</script>";
     String result = gson.toJson(target);
@@ -704,6 +783,7 @@ public class PrimitiveTest extends TestCase {
     assertTrue(result.equals('"' + target + '"'));
   }
 
+  @Test
   public void testDeserializePrimitiveWrapperAsObjectField() {
     String json = "{i:10}";
     ClassWithIntegerField target = gson.fromJson(json, ClassWithIntegerField.class);
@@ -714,12 +794,14 @@ public class PrimitiveTest extends TestCase {
     Integer i;
   }
 
+  @Test
   public void testPrimitiveClassLiteral() {
     assertEquals(1, gson.fromJson("1", int.class).intValue());
     assertEquals(1, gson.fromJson(new StringReader("1"), int.class).intValue());
     assertEquals(1, gson.fromJson(new JsonPrimitive(1), int.class).intValue());
   }
 
+  @Test
   public void testDeserializeJsonObjectAsLongPrimitive() {
     try {
       gson.fromJson("{'abc':1}", long.class);
@@ -727,6 +809,7 @@ public class PrimitiveTest extends TestCase {
     } catch (JsonSyntaxException expected) {}
   }
 
+  @Test
   public void testDeserializeJsonArrayAsLongWrapper() {
     try {
       gson.fromJson("[1,2,3]", Long.class);
@@ -734,6 +817,7 @@ public class PrimitiveTest extends TestCase {
     } catch (JsonSyntaxException expected) {}
   }
 
+  @Test
   public void testDeserializeJsonArrayAsInt() {
     try {
       gson.fromJson("[1, 2, 3, 4]", int.class);
@@ -741,6 +825,7 @@ public class PrimitiveTest extends TestCase {
     } catch (JsonSyntaxException expected) {}
   }
 
+  @Test
   public void testDeserializeJsonObjectAsInteger() {
     try {
       gson.fromJson("{}", Integer.class);
@@ -748,6 +833,7 @@ public class PrimitiveTest extends TestCase {
     } catch (JsonSyntaxException expected) {}
   }
 
+  @Test
   public void testDeserializeJsonObjectAsShortPrimitive() {
     try {
       gson.fromJson("{'abc':1}", short.class);
@@ -755,6 +841,7 @@ public class PrimitiveTest extends TestCase {
     } catch (JsonSyntaxException expected) {}
   }
 
+  @Test
   public void testDeserializeJsonArrayAsShortWrapper() {
     try {
       gson.fromJson("['a','b']", Short.class);
@@ -762,6 +849,7 @@ public class PrimitiveTest extends TestCase {
     } catch (JsonSyntaxException expected) {}
   }
 
+  @Test
   public void testDeserializeJsonArrayAsDoublePrimitive() {
     try {
       gson.fromJson("[1,2]", double.class);
@@ -769,6 +857,7 @@ public class PrimitiveTest extends TestCase {
     } catch (JsonSyntaxException expected) {}
   }
 
+  @Test
   public void testDeserializeJsonObjectAsDoubleWrapper() {
     try {
       gson.fromJson("{'abc':1}", Double.class);
@@ -776,6 +865,7 @@ public class PrimitiveTest extends TestCase {
     } catch (JsonSyntaxException expected) {}
   }
 
+  @Test
   public void testDeserializeJsonObjectAsFloatPrimitive() {
     try {
       gson.fromJson("{'abc':1}", float.class);
@@ -783,6 +873,7 @@ public class PrimitiveTest extends TestCase {
     } catch (JsonSyntaxException expected) {}
   }
 
+  @Test
   public void testDeserializeJsonArrayAsFloatWrapper() {
     try {
       gson.fromJson("[1,2,3]", Float.class);
@@ -790,6 +881,7 @@ public class PrimitiveTest extends TestCase {
     } catch (JsonSyntaxException expected) {}
   }
 
+  @Test
   public void testDeserializeJsonObjectAsBytePrimitive() {
     try {
       gson.fromJson("{'abc':1}", byte.class);
@@ -797,6 +889,7 @@ public class PrimitiveTest extends TestCase {
     } catch (JsonSyntaxException expected) {}
   }
 
+  @Test
   public void testDeserializeJsonArrayAsByteWrapper() {
     try {
       gson.fromJson("[1,2,3,4]", Byte.class);
@@ -804,6 +897,7 @@ public class PrimitiveTest extends TestCase {
     } catch (JsonSyntaxException expected) {}
   }
 
+  @Test
   public void testDeserializeJsonObjectAsBooleanPrimitive() {
     try {
       gson.fromJson("{'abc':1}", boolean.class);
@@ -811,6 +905,7 @@ public class PrimitiveTest extends TestCase {
     } catch (JsonSyntaxException expected) {}
   }
 
+  @Test
   public void testDeserializeJsonArrayAsBooleanWrapper() {
     try {
       gson.fromJson("[1,2,3,4]", Boolean.class);
@@ -818,6 +913,7 @@ public class PrimitiveTest extends TestCase {
     } catch (JsonSyntaxException expected) {}
   }
 
+  @Test
   public void testDeserializeJsonArrayAsBigDecimal() {
     try {
       gson.fromJson("[1,2,3,4]", BigDecimal.class);
@@ -825,6 +921,7 @@ public class PrimitiveTest extends TestCase {
     } catch (JsonSyntaxException expected) {}
   }
 
+  @Test
   public void testDeserializeJsonObjectAsBigDecimal() {
     try {
       gson.fromJson("{'a':1}", BigDecimal.class);
@@ -832,6 +929,7 @@ public class PrimitiveTest extends TestCase {
     } catch (JsonSyntaxException expected) {}
   }
 
+  @Test
   public void testDeserializeJsonArrayAsBigInteger() {
     try {
       gson.fromJson("[1,2,3,4]", BigInteger.class);
@@ -839,6 +937,7 @@ public class PrimitiveTest extends TestCase {
     } catch (JsonSyntaxException expected) {}
   }
 
+  @Test
   public void testDeserializeJsonObjectAsBigInteger() {
     try {
       gson.fromJson("{'c':2}", BigInteger.class);
@@ -846,6 +945,7 @@ public class PrimitiveTest extends TestCase {
     } catch (JsonSyntaxException expected) {}
   }
 
+  @Test
   public void testDeserializeJsonArrayAsNumber() {
     try {
       gson.fromJson("[1,2,3,4]", Number.class);
@@ -853,6 +953,7 @@ public class PrimitiveTest extends TestCase {
     } catch (JsonSyntaxException expected) {}
   }
 
+  @Test
   public void testDeserializeJsonObjectAsNumber() {
     try {
       gson.fromJson("{'c':2}", Number.class);
@@ -860,10 +961,12 @@ public class PrimitiveTest extends TestCase {
     } catch (JsonSyntaxException expected) {}
   }
 
+  @Test
   public void testDeserializingDecimalPointValueZeroSucceeds() {
     assertEquals(1, (int) gson.fromJson("1.0", Integer.class));
   }
 
+  @Test
   public void testDeserializingNonZeroDecimalPointValuesAsIntegerFails() {
     try {
       gson.fromJson("1.02", Byte.class);
@@ -887,6 +990,7 @@ public class PrimitiveTest extends TestCase {
     }
   }
 
+  @Test
   public void testDeserializingBigDecimalAsIntegerFails() {
     try {
       gson.fromJson("-122.08e-213", Integer.class);
@@ -895,6 +999,7 @@ public class PrimitiveTest extends TestCase {
     }
   }
 
+  @Test
   public void testDeserializingBigIntegerAsInteger() {
     try {
       gson.fromJson("12121211243123245845384534687435634558945453489543985435", Integer.class);
@@ -903,6 +1008,7 @@ public class PrimitiveTest extends TestCase {
     }
   }
 
+  @Test
   public void testDeserializingBigIntegerAsLong() {
     try {
       gson.fromJson("12121211243123245845384534687435634558945453489543985435", Long.class);
@@ -911,29 +1017,33 @@ public class PrimitiveTest extends TestCase {
     }
   }
 
+  @Test
   public void testValueVeryCloseToZeroIsZero() {
     assertEquals(0, (byte) gson.fromJson("-122.08e-2132", byte.class));
     assertEquals(0, (short) gson.fromJson("-122.08e-2132", short.class));
     assertEquals(0, (int) gson.fromJson("-122.08e-2132", int.class));
     assertEquals(0, (long) gson.fromJson("-122.08e-2132", long.class));
-    assertEquals(-0.0f, gson.fromJson("-122.08e-2132", float.class));
-    assertEquals(-0.0, gson.fromJson("-122.08e-2132", double.class));
-    assertEquals(0.0f, gson.fromJson("122.08e-2132", float.class));
-    assertEquals(0.0, gson.fromJson("122.08e-2132", double.class));
+    assertEquals(-0.0f, gson.fromJson("-122.08e-2132", float.class), 0);
+    assertEquals(-0.0, gson.fromJson("-122.08e-2132", double.class), 0);
+    assertEquals(0.0f, gson.fromJson("122.08e-2132", float.class), 0);
+    assertEquals(0.0, gson.fromJson("122.08e-2132", double.class), 0);
   }
 
+  @Test
   public void testDeserializingBigDecimalAsFloat() {
     String json = "-122.08e-2132332";
     float actual = gson.fromJson(json, float.class);
-    assertEquals(-0.0f, actual);
+    assertEquals(-0.0f, actual, 0);
   }
 
+  @Test
   public void testDeserializingBigDecimalAsDouble() {
     String json = "-122.08e-2132332";
     double actual = gson.fromJson(json, double.class);
-    assertEquals(-0.0d, actual);
+    assertEquals(-0.0d, actual, 0);
   }
 
+  @Test
   public void testDeserializingBigDecimalAsBigIntegerFails() {
     try {
       gson.fromJson("-122.08e-213", BigInteger.class);
@@ -942,12 +1052,14 @@ public class PrimitiveTest extends TestCase {
     }
   }
 
+  @Test
   public void testDeserializingBigIntegerAsBigDecimal() {
     BigDecimal actual =
       gson.fromJson("12121211243123245845384534687435634558945453489543985435", BigDecimal.class);
     assertEquals("12121211243123245845384534687435634558945453489543985435", actual.toPlainString());
   }
 
+  @Test
   public void testStringsAsBooleans() {
     String json = "['true', 'false', 'TRUE', 'yes', '1']";
     assertEquals(Arrays.asList(true, false, true, false, false),
diff --git a/gson/src/test/java/com/google/gson/functional/PrintFormattingTest.java b/gson/src/test/java/com/google/gson/functional/PrintFormattingTest.java
index 6801ba00..55d7606c 100644
--- a/gson/src/test/java/com/google/gson/functional/PrintFormattingTest.java
+++ b/gson/src/test/java/com/google/gson/functional/PrintFormattingTest.java
@@ -16,6 +16,9 @@
 
 package com.google.gson.functional;
 
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
 import com.google.gson.JsonObject;
@@ -25,7 +28,8 @@ import com.google.gson.common.TestTypes.Nested;
 import com.google.gson.common.TestTypes.PrimitiveArray;
 import java.util.ArrayList;
 import java.util.List;
-import junit.framework.TestCase;
+import org.junit.Before;
+import org.junit.Test;
 
 /**
  * Functional tests for print formatting.
@@ -33,16 +37,16 @@ import junit.framework.TestCase;
  * @author Inderjeet Singh
  * @author Joel Leitch
  */
-public class PrintFormattingTest extends TestCase {
+public class PrintFormattingTest {
 
   private Gson gson;
 
-  @Override
-  protected void setUp() throws Exception {
-    super.setUp();
+  @Before
+  public void setUp() throws Exception {
     gson = new Gson();
   }
 
+  @Test
   public void testCompactFormattingLeavesNoWhiteSpace() {
     List<Object> list = new ArrayList<>();
     list.add(new BagOfPrimitives());
@@ -54,6 +58,7 @@ public class PrintFormattingTest extends TestCase {
     assertContainsNoWhiteSpace(json);
   }
 
+  @Test
   public void testJsonObjectWithNullValues() {
     JsonObject obj = new JsonObject();
     obj.addProperty("field1", "value1");
@@ -63,6 +68,7 @@ public class PrintFormattingTest extends TestCase {
     assertFalse(json.contains("field2"));
   }
 
+  @Test
   public void testJsonObjectWithNullValuesSerialized() {
     gson = new GsonBuilder().serializeNulls().create();
     JsonObject obj = new JsonObject();
diff --git a/gson/src/test/java/com/google/gson/functional/RawSerializationTest.java b/gson/src/test/java/com/google/gson/functional/RawSerializationTest.java
index 7876999d..6e7ada6e 100644
--- a/gson/src/test/java/com/google/gson/functional/RawSerializationTest.java
+++ b/gson/src/test/java/com/google/gson/functional/RawSerializationTest.java
@@ -15,41 +15,44 @@
  */
 package com.google.gson.functional;
 
-import java.util.Arrays;
-import java.util.Collection;
-
-import junit.framework.TestCase;
+import static org.junit.Assert.assertEquals;
 
 import com.google.gson.Gson;
 import com.google.gson.reflect.TypeToken;
+import java.util.Arrays;
+import java.util.Collection;
+import org.junit.Before;
+import org.junit.Test;
 
 /**
  * Unit tests to validate serialization of parameterized types without explicit types
  *
  * @author Inderjeet Singh
  */
-public class RawSerializationTest extends TestCase {
+public class RawSerializationTest {
 
   private Gson gson;
 
-  @Override
-  protected void setUp() throws Exception {
-    super.setUp();
+  @Before
+  public void setUp() throws Exception {
     gson = new Gson();
   }
 
+  @Test
   public void testCollectionOfPrimitives() {
     Collection<Integer> ints = Arrays.asList(1, 2, 3, 4, 5);
     String json = gson.toJson(ints);
     assertEquals("[1,2,3,4,5]", json);
   }
 
+  @Test
   public void testCollectionOfObjects() {
     Collection<Foo> foos = Arrays.asList(new Foo(1), new Foo(2));
     String json = gson.toJson(foos);
     assertEquals("[{\"b\":1},{\"b\":2}]", json);
   }
 
+  @Test
   public void testParameterizedObject() {
     Bar<Foo> bar = new Bar<>(new Foo(1));
     String expectedJson = "{\"t\":{\"b\":1}}";
@@ -61,6 +64,7 @@ public class RawSerializationTest extends TestCase {
     assertEquals(expectedJson, json);
   }
 
+  @Test
   public void testTwoLevelParameterizedObject() {
     Bar<Bar<Foo>> bar = new Bar<>(new Bar<>(new Foo(1)));
     String expectedJson = "{\"t\":{\"t\":{\"b\":1}}}";
@@ -72,6 +76,7 @@ public class RawSerializationTest extends TestCase {
     assertEquals(expectedJson, json);
   }
 
+  @Test
   public void testThreeLevelParameterizedObject() {
     Bar<Bar<Bar<Foo>>> bar = new Bar<>(new Bar<>(new Bar<>(new Foo(1))));
     String expectedJson = "{\"t\":{\"t\":{\"t\":{\"b\":1}}}}";
diff --git a/gson/src/test/java/com/google/gson/functional/ReadersWritersTest.java b/gson/src/test/java/com/google/gson/functional/ReadersWritersTest.java
index a04723b5..4862cda4 100644
--- a/gson/src/test/java/com/google/gson/functional/ReadersWritersTest.java
+++ b/gson/src/test/java/com/google/gson/functional/ReadersWritersTest.java
@@ -15,6 +15,12 @@
  */
 package com.google.gson.functional;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
 import com.google.gson.JsonStreamParser;
@@ -30,7 +36,8 @@ import java.io.StringWriter;
 import java.io.Writer;
 import java.util.Arrays;
 import java.util.Map;
-import junit.framework.TestCase;
+import org.junit.Before;
+import org.junit.Test;
 
 /**
  * Functional tests for the support of {@link Reader}s and {@link Writer}s.
@@ -38,15 +45,15 @@ import junit.framework.TestCase;
  * @author Inderjeet Singh
  * @author Joel Leitch
  */
-public class ReadersWritersTest extends TestCase {
+public class ReadersWritersTest {
   private Gson gson;
 
-  @Override
-  protected void setUp() throws Exception {
-    super.setUp();
+  @Before
+  public void setUp() throws Exception {
     gson = new Gson();
   }
 
+  @Test
   public void testWriterForSerialization() throws Exception {
     Writer writer = new StringWriter();
     BagOfPrimitives src = new BagOfPrimitives();
@@ -54,6 +61,7 @@ public class ReadersWritersTest extends TestCase {
     assertEquals(src.getExpectedJson(), writer.toString());
   }
 
+  @Test
   public void testReaderForDeserialization() throws Exception {
     BagOfPrimitives expected = new BagOfPrimitives();
     Reader json = new StringReader(expected.getExpectedJson());
@@ -61,18 +69,21 @@ public class ReadersWritersTest extends TestCase {
     assertEquals(expected, actual);
   }
 
+  @Test
   public void testTopLevelNullObjectSerializationWithWriter() {
     StringWriter writer = new StringWriter();
     gson.toJson(null, writer);
     assertEquals("null", writer.toString());
   }
 
+  @Test
   public void testTopLevelNullObjectDeserializationWithReader() {
     StringReader reader = new StringReader("null");
     Integer nullIntObject = gson.fromJson(reader, Integer.class);
     assertNull(nullIntObject);
   }
 
+  @Test
   public void testTopLevelNullObjectSerializationWithWriterAndSerializeNulls() {
     Gson gson = new GsonBuilder().serializeNulls().create();
     StringWriter writer = new StringWriter();
@@ -80,6 +91,7 @@ public class ReadersWritersTest extends TestCase {
     assertEquals("null", writer.toString());
   }
 
+  @Test
   public void testTopLevelNullObjectDeserializationWithReaderAndSerializeNulls() {
     Gson gson = new GsonBuilder().serializeNulls().create();
     StringReader reader = new StringReader("null");
@@ -87,6 +99,7 @@ public class ReadersWritersTest extends TestCase {
     assertNull(nullIntObject);
   }
 
+  @Test
   public void testReadWriteTwoStrings() throws IOException {
     Gson gson = new Gson();
     CharArrayWriter writer = new CharArrayWriter();
@@ -100,6 +113,7 @@ public class ReadersWritersTest extends TestCase {
     assertEquals("two", actualTwo);
   }
 
+  @Test
   public void testReadWriteTwoObjects() throws IOException {
     Gson gson = new Gson();
     CharArrayWriter writer = new CharArrayWriter();
@@ -116,6 +130,7 @@ public class ReadersWritersTest extends TestCase {
     assertFalse(parser.hasNext());
   }
 
+  @Test
   public void testTypeMismatchThrowsJsonSyntaxExceptionForStrings() {
     try {
       gson.fromJson("true", new TypeToken<Map<String, String>>() {}.getType());
@@ -124,6 +139,7 @@ public class ReadersWritersTest extends TestCase {
     }
   }
 
+  @Test
   public void testTypeMismatchThrowsJsonSyntaxExceptionForReaders() {
     try {
       gson.fromJson(new StringReader("true"), new TypeToken<Map<String, String>>() {}.getType());
@@ -136,6 +152,7 @@ public class ReadersWritersTest extends TestCase {
    * Verifies that passing an {@link Appendable} which is not an instance of {@link Writer}
    * to {@code Gson.toJson} works correctly.
    */
+  @Test
   public void testToJsonAppendable() {
     class CustomAppendable implements Appendable {
       final StringBuilder stringBuilder = new StringBuilder();
diff --git a/gson/src/test/java/com/google/gson/functional/RuntimeTypeAdapterFactoryFunctionalTest.java b/gson/src/test/java/com/google/gson/functional/RuntimeTypeAdapterFactoryFunctionalTest.java
index 0c6bd07a..c17cc54a 100644
--- a/gson/src/test/java/com/google/gson/functional/RuntimeTypeAdapterFactoryFunctionalTest.java
+++ b/gson/src/test/java/com/google/gson/functional/RuntimeTypeAdapterFactoryFunctionalTest.java
@@ -15,11 +15,7 @@
  */
 package com.google.gson.functional;
 
-import java.io.IOException;
-import java.util.LinkedHashMap;
-import java.util.Map;
-
-import junit.framework.TestCase;
+import static org.junit.Assert.assertEquals;
 
 import com.google.gson.Gson;
 import com.google.gson.JsonElement;
@@ -33,11 +29,15 @@ import com.google.gson.internal.Streams;
 import com.google.gson.reflect.TypeToken;
 import com.google.gson.stream.JsonReader;
 import com.google.gson.stream.JsonWriter;
+import java.io.IOException;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import org.junit.Test;
 
 /**
  * Functional tests for the RuntimeTypeAdapterFactory feature in extras.
  */
-public final class RuntimeTypeAdapterFactoryFunctionalTest extends TestCase {
+public final class RuntimeTypeAdapterFactoryFunctionalTest {
 
   private final Gson gson = new Gson();
 
@@ -45,6 +45,7 @@ public final class RuntimeTypeAdapterFactoryFunctionalTest extends TestCase {
    * This test also ensures that {@link TypeAdapterFactory} registered through {@link JsonAdapter}
    * work correctly for {@link Gson#getDelegateAdapter(TypeAdapterFactory, TypeToken)}.
    */
+  @Test
   public void testSubclassesAutomaticallySerialized() throws Exception {
     Shape shape = new Circle(25);
     String json = gson.toJson(shape);
diff --git a/gson/src/test/java/com/google/gson/functional/SecurityTest.java b/gson/src/test/java/com/google/gson/functional/SecurityTest.java
index 3c7f63f7..3cb76335 100644
--- a/gson/src/test/java/com/google/gson/functional/SecurityTest.java
+++ b/gson/src/test/java/com/google/gson/functional/SecurityTest.java
@@ -16,18 +16,21 @@
 
 package com.google.gson.functional;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
 import com.google.gson.common.TestTypes.BagOfPrimitives;
-
-import junit.framework.TestCase;
+import org.junit.Before;
+import org.junit.Test;
 
 /**
  * Tests for security-related aspects of Gson
  * 
  * @author Inderjeet Singh
  */
-public class SecurityTest extends TestCase {
+public class SecurityTest {
   /**
    * Keep this in sync with Gson.JSON_NON_EXECUTABLE_PREFIX
    */
@@ -35,18 +38,19 @@ public class SecurityTest extends TestCase {
 
   private GsonBuilder gsonBuilder;
 
-  @Override
-  protected void setUp() throws Exception {
-    super.setUp();
+  @Before
+  public void setUp() throws Exception {
     gsonBuilder = new GsonBuilder().setLenient();
   }
 
+  @Test
   public void testNonExecutableJsonSerialization() {
     Gson gson = gsonBuilder.generateNonExecutableJson().create();
     String json = gson.toJson(new BagOfPrimitives());
     assertTrue(json.startsWith(JSON_NON_EXECUTABLE_PREFIX));
   }
   
+  @Test
   public void testNonExecutableJsonDeserialization() {
     String json = JSON_NON_EXECUTABLE_PREFIX + "{longValue:1}";
     Gson gson = gsonBuilder.create();
@@ -54,6 +58,7 @@ public class SecurityTest extends TestCase {
     assertEquals(1, target.longValue);
   }
   
+  @Test
   public void testJsonWithNonExectuableTokenSerialization() {
     Gson gson = gsonBuilder.generateNonExecutableJson().create();
     String json = gson.toJson(JSON_NON_EXECUTABLE_PREFIX);
@@ -64,6 +69,7 @@ public class SecurityTest extends TestCase {
    *  Gson should be able to deserialize a stream with non-exectuable token even if it is created
    *  without {@link GsonBuilder#generateNonExecutableJson()}.
    */
+  @Test
   public void testJsonWithNonExectuableTokenWithRegularGsonDeserialization() {
     Gson gson = gsonBuilder.create();
     String json = JSON_NON_EXECUTABLE_PREFIX + "{stringValue:')]}\\u0027\\n'}";
@@ -75,6 +81,7 @@ public class SecurityTest extends TestCase {
    *  Gson should be able to deserialize a stream with non-exectuable token if it is created
    *  with {@link GsonBuilder#generateNonExecutableJson()}.
    */
+  @Test
   public void testJsonWithNonExectuableTokenWithConfiguredGsonDeserialization() {
     // Gson should be able to deserialize a stream with non-exectuable token even if it is created 
     Gson gson = gsonBuilder.generateNonExecutableJson().create();
diff --git a/gson/src/test/java/com/google/gson/functional/SerializedNameTest.java b/gson/src/test/java/com/google/gson/functional/SerializedNameTest.java
index 0314ae0a..a1633700 100644
--- a/gson/src/test/java/com/google/gson/functional/SerializedNameTest.java
+++ b/gson/src/test/java/com/google/gson/functional/SerializedNameTest.java
@@ -15,20 +15,23 @@
  */
 package com.google.gson.functional;
 
+import static org.junit.Assert.assertEquals;
+
 import com.google.gson.Gson;
 import com.google.gson.annotations.SerializedName;
+import org.junit.Test;
 
-import junit.framework.TestCase;
-
-public final class SerializedNameTest extends TestCase {
+public final class SerializedNameTest {
   private final Gson gson = new Gson();
 
+  @Test
   public void testFirstNameIsChosenForSerialization() {
     MyClass target = new MyClass("v1", "v2");
     // Ensure name1 occurs exactly once, and name2 and name3 don't appear
     assertEquals("{\"name\":\"v1\",\"name1\":\"v2\"}", gson.toJson(target));
   }
 
+  @Test
   public void testMultipleNamesDeserializedCorrectly() {
     assertEquals("v1", gson.fromJson("{'name':'v1'}", MyClass.class).a);
 
@@ -38,6 +41,7 @@ public final class SerializedNameTest extends TestCase {
     assertEquals("v3", gson.fromJson("{'name3':'v3'}", MyClass.class).b);
   }
 
+  @Test
   public void testMultipleNamesInTheSameString() {
     // The last value takes precedence
     assertEquals("v3", gson.fromJson("{'name1':'v1','name2':'v2','name3':'v3'}", MyClass.class).b);
diff --git a/gson/src/test/java/com/google/gson/functional/StreamingTypeAdaptersTest.java b/gson/src/test/java/com/google/gson/functional/StreamingTypeAdaptersTest.java
index c516ec87..d91bd0bb 100644
--- a/gson/src/test/java/com/google/gson/functional/StreamingTypeAdaptersTest.java
+++ b/gson/src/test/java/com/google/gson/functional/StreamingTypeAdaptersTest.java
@@ -16,6 +16,11 @@
 
 package com.google.gson.functional;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
 import com.google.gson.JsonArray;
@@ -33,14 +38,15 @@ import java.util.Collections;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
-import junit.framework.TestCase;
+import org.junit.Test;
 
-public final class StreamingTypeAdaptersTest extends TestCase {
+public final class StreamingTypeAdaptersTest {
   private Gson miniGson = new GsonBuilder().create();
   private TypeAdapter<Truck> truckAdapter = miniGson.getAdapter(Truck.class);
   private TypeAdapter<Map<String, Double>> mapAdapter
       = miniGson.getAdapter(new TypeToken<Map<String, Double>>() {});
 
+  @Test
   public void testSerialize() {
     Truck truck = new Truck();
     truck.passengers = Arrays.asList(new Person("Jesse", 29), new Person("Jodie", 29));
@@ -51,14 +57,16 @@ public final class StreamingTypeAdaptersTest extends TestCase {
         truckAdapter.toJson(truck).replace('\"', '\''));
   }
 
+  @Test
   public void testDeserialize() throws IOException {
     String json = "{'horsePower':300.0,"
         + "'passengers':[{'age':29,'name':'Jesse'},{'age':29,'name':'Jodie'}]}";
     Truck truck = truckAdapter.fromJson(json.replace('\'', '\"'));
-    assertEquals(300.0, truck.horsePower);
+    assertEquals(300.0, truck.horsePower, 0);
     assertEquals(Arrays.asList(new Person("Jesse", 29), new Person("Jodie", 29)), truck.passengers);
   }
 
+  @Test
   public void testSerializeNullField() {
     Truck truck = new Truck();
     truck.passengers = null;
@@ -66,11 +74,13 @@ public final class StreamingTypeAdaptersTest extends TestCase {
         truckAdapter.toJson(truck).replace('\"', '\''));
   }
 
+  @Test
   public void testDeserializeNullField() throws IOException {
     Truck truck = truckAdapter.fromJson("{'horsePower':0.0,'passengers':null}".replace('\'', '\"'));
     assertNull(truck.passengers);
   }
 
+  @Test
   public void testSerializeNullObject() {
     Truck truck = new Truck();
     truck.passengers = Arrays.asList((Person) null);
@@ -78,11 +88,13 @@ public final class StreamingTypeAdaptersTest extends TestCase {
         truckAdapter.toJson(truck).replace('\"', '\''));
   }
 
+  @Test
   public void testDeserializeNullObject() throws IOException {
     Truck truck = truckAdapter.fromJson("{'horsePower':0.0,'passengers':[null]}".replace('\'', '\"'));
     assertEquals(Arrays.asList((Person) null), truck.passengers);
   }
 
+  @Test
   public void testSerializeWithCustomTypeAdapter() {
     usePersonNameAdapter();
     Truck truck = new Truck();
@@ -91,6 +103,7 @@ public final class StreamingTypeAdaptersTest extends TestCase {
         truckAdapter.toJson(truck).replace('\"', '\''));
   }
 
+  @Test
   public void testDeserializeWithCustomTypeAdapter() throws IOException {
     usePersonNameAdapter();
     Truck truck = truckAdapter.fromJson("{'horsePower':0.0,'passengers':['Jesse','Jodie']}".replace('\'', '\"'));
@@ -111,6 +124,7 @@ public final class StreamingTypeAdaptersTest extends TestCase {
     truckAdapter = miniGson.getAdapter(Truck.class);
   }
 
+  @Test
   public void testSerializeMap() {
     Map<String, Double> map = new LinkedHashMap<>();
     map.put("a", 5.0);
@@ -118,6 +132,7 @@ public final class StreamingTypeAdaptersTest extends TestCase {
     assertEquals("{'a':5.0,'b':10.0}", mapAdapter.toJson(map).replace('"', '\''));
   }
 
+  @Test
   public void testDeserializeMap() throws IOException {
     Map<String, Double> map = new LinkedHashMap<>();
     map.put("a", 5.0);
@@ -125,23 +140,27 @@ public final class StreamingTypeAdaptersTest extends TestCase {
     assertEquals(map, mapAdapter.fromJson("{'a':5.0,'b':10.0}".replace('\'', '\"')));
   }
 
+  @Test
   public void testSerialize1dArray() {
     TypeAdapter<double[]> arrayAdapter = miniGson.getAdapter(new TypeToken<double[]>() {});
     assertEquals("[1.0,2.0,3.0]", arrayAdapter.toJson(new double[]{ 1.0, 2.0, 3.0 }));
   }
 
+  @Test
   public void testDeserialize1dArray() throws IOException {
     TypeAdapter<double[]> arrayAdapter = miniGson.getAdapter(new TypeToken<double[]>() {});
     double[] array = arrayAdapter.fromJson("[1.0,2.0,3.0]");
     assertTrue(Arrays.toString(array), Arrays.equals(new double[]{1.0, 2.0, 3.0}, array));
   }
 
+  @Test
   public void testSerialize2dArray() {
     TypeAdapter<double[][]> arrayAdapter = miniGson.getAdapter(new TypeToken<double[][]>() {});
     double[][] array = { {1.0, 2.0 }, { 3.0 } };
     assertEquals("[[1.0,2.0],[3.0]]", arrayAdapter.toJson(array));
   }
 
+  @Test
   public void testDeserialize2dArray() throws IOException {
     TypeAdapter<double[][]> arrayAdapter = miniGson.getAdapter(new TypeToken<double[][]>() {});
     double[][] array = arrayAdapter.fromJson("[[1.0,2.0],[3.0]]");
@@ -149,6 +168,7 @@ public final class StreamingTypeAdaptersTest extends TestCase {
     assertTrue(Arrays.toString(array), Arrays.deepEquals(expected, array));
   }
 
+  @Test
   public void testNullSafe() {
     TypeAdapter<Person> typeAdapter = new TypeAdapter<Person>() {
       @Override public Person read(JsonReader in) throws IOException {
@@ -179,11 +199,12 @@ public final class StreamingTypeAdaptersTest extends TestCase {
     assertEquals("{\"horsePower\":1.0,\"passengers\":[null,\"jesse,30\"]}",
         gson.toJson(truck, Truck.class));
     truck = gson.fromJson(json, Truck.class);
-    assertEquals(1.0D, truck.horsePower);
+    assertEquals(1.0D, truck.horsePower, 0);
     assertNull(truck.passengers.get(0));
     assertEquals("jesse", truck.passengers.get(1).name);
   }
 
+  @Test
   public void testSerializeRecursive() {
     TypeAdapter<Node> nodeAdapter = miniGson.getAdapter(Node.class);
     Node root = new Node("root");
@@ -195,6 +216,7 @@ public final class StreamingTypeAdaptersTest extends TestCase {
         nodeAdapter.toJson(root).replace('"', '\''));
   }
   
+  @Test
   public void testFromJsonTree() {
     JsonObject truckObject = new JsonObject();
     truckObject.add("horsePower", new JsonPrimitive(300));
@@ -206,7 +228,7 @@ public final class StreamingTypeAdaptersTest extends TestCase {
     truckObject.add("passengers", passengersArray);
 
     Truck truck = truckAdapter.fromJsonTree(truckObject);
-    assertEquals(300.0, truck.horsePower);
+    assertEquals(300.0, truck.horsePower, 0);
     assertEquals(Arrays.asList(new Person("Jesse", 30)), truck.passengers);
   }
 
diff --git a/gson/src/test/java/com/google/gson/functional/StringTest.java b/gson/src/test/java/com/google/gson/functional/StringTest.java
index 7dcf6f0f..80c73831 100644
--- a/gson/src/test/java/com/google/gson/functional/StringTest.java
+++ b/gson/src/test/java/com/google/gson/functional/StringTest.java
@@ -1,8 +1,10 @@
 package com.google.gson.functional;
 
-import com.google.gson.Gson;
+import static org.junit.Assert.assertEquals;
 
-import junit.framework.TestCase;
+import com.google.gson.Gson;
+import org.junit.Before;
+import org.junit.Test;
 
 /**
  * Functional tests for Json serialization and deserialization of strings.
@@ -10,73 +12,83 @@ import junit.framework.TestCase;
  * @author Inderjeet Singh
  * @author Joel Leitch
  */
-public class StringTest extends TestCase {
+public class StringTest {
   private Gson gson;
 
-  @Override
-  protected void setUp() throws Exception {
-    super.setUp();
+  @Before
+  public void setUp() throws Exception {
     gson = new Gson();
   }
 
+  @Test
   public void testStringValueSerialization() throws Exception {
     String value = "someRandomStringValue";
     assertEquals('"' + value + '"', gson.toJson(value));
   }
 
+  @Test
   public void testStringValueDeserialization() throws Exception {
     String value = "someRandomStringValue";
     String actual = gson.fromJson("\"" + value + "\"", String.class);
     assertEquals(value, actual);
   }
 
+  @Test
   public void testSingleQuoteInStringSerialization() throws Exception {
     String valueWithQuotes = "beforeQuote'afterQuote";
     String jsonRepresentation = gson.toJson(valueWithQuotes);
     assertEquals(valueWithQuotes, gson.fromJson(jsonRepresentation, String.class));
   }
 
+  @Test
   public void testEscapedCtrlNInStringSerialization() throws Exception {
     String value = "a\nb";
     String json = gson.toJson(value);
     assertEquals("\"a\\nb\"", json);
   }
 
+  @Test
   public void testEscapedCtrlNInStringDeserialization() throws Exception {
     String json = "'a\\nb'";
     String actual = gson.fromJson(json, String.class);
     assertEquals("a\nb", actual);
   }
 
+  @Test
   public void testEscapedCtrlRInStringSerialization() throws Exception {
     String value = "a\rb";
     String json = gson.toJson(value);
     assertEquals("\"a\\rb\"", json);
   }
 
+  @Test
   public void testEscapedCtrlRInStringDeserialization() throws Exception {
     String json = "'a\\rb'";
     String actual = gson.fromJson(json, String.class);
     assertEquals("a\rb", actual);
   }
 
+  @Test
   public void testEscapedBackslashInStringSerialization() throws Exception {
     String value = "a\\b";
     String json = gson.toJson(value);
     assertEquals("\"a\\\\b\"", json);
   }
 
+  @Test
   public void testEscapedBackslashInStringDeserialization() throws Exception {
     String actual = gson.fromJson("'a\\\\b'", String.class);
     assertEquals("a\\b", actual);
   }
 
+  @Test
   public void testSingleQuoteInStringDeserialization() throws Exception {
     String value = "beforeQuote'afterQuote";
     String actual = gson.fromJson("\"" + value + "\"", String.class);
     assertEquals(value, actual);
   }
 
+  @Test
   public void testEscapingQuotesInStringSerialization() throws Exception {
     String valueWithQuotes = "beforeQuote\"afterQuote";
     String jsonRepresentation = gson.toJson(valueWithQuotes);
@@ -84,6 +96,7 @@ public class StringTest extends TestCase {
     assertEquals(valueWithQuotes, target);
   }
 
+  @Test
   public void testEscapingQuotesInStringDeserialization() throws Exception {
     String value = "beforeQuote\\\"afterQuote";
     String actual = gson.fromJson("\"" + value + "\"", String.class);
@@ -91,12 +104,14 @@ public class StringTest extends TestCase {
     assertEquals(expected, actual);
   }
 
+  @Test
   public void testStringValueAsSingleElementArraySerialization() throws Exception {
     String[] target = {"abc"};
     assertEquals("[\"abc\"]", gson.toJson(target));
     assertEquals("[\"abc\"]", gson.toJson(target, String[].class));
   }
 
+  @Test
   public void testStringWithEscapedSlashDeserialization() {
     String value = "/";
     String json = "'\\/'";
@@ -107,6 +122,7 @@ public class StringTest extends TestCase {
   /**
    * Created in response to http://groups.google.com/group/google-gson/browse_thread/thread/2431d4a3d0d6cb23
    */
+  @Test
   public void testAssignmentCharSerialization() {
     String value = "abc=";
     String json = gson.toJson(value);
@@ -116,6 +132,7 @@ public class StringTest extends TestCase {
   /**
    * Created in response to http://groups.google.com/group/google-gson/browse_thread/thread/2431d4a3d0d6cb23
    */
+  @Test
   public void testAssignmentCharDeserialization() {
     String json = "\"abc=\"";
     String value = gson.fromJson(json, String.class);
@@ -126,12 +143,14 @@ public class StringTest extends TestCase {
     assertEquals("abc=", value);
   }
 
+  @Test
   public void testJavascriptKeywordsInStringSerialization() {
     String value = "null true false function";
     String json = gson.toJson(value);
     assertEquals("\"" + value + "\"", json);
   }
 
+  @Test
   public void testJavascriptKeywordsInStringDeserialization() {
     String json = "'null true false function'";
     String value = gson.fromJson(json, String.class);
diff --git a/gson/src/test/java/com/google/gson/functional/ToNumberPolicyFunctionalTest.java b/gson/src/test/java/com/google/gson/functional/ToNumberPolicyFunctionalTest.java
index 3e261d56..1e772836 100644
--- a/gson/src/test/java/com/google/gson/functional/ToNumberPolicyFunctionalTest.java
+++ b/gson/src/test/java/com/google/gson/functional/ToNumberPolicyFunctionalTest.java
@@ -16,12 +16,9 @@
 
 package com.google.gson.functional;
 
-import java.lang.reflect.Type;
-import java.math.BigDecimal;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.LinkedList;
-import java.util.List;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
 import com.google.gson.ToNumberPolicy;
@@ -29,9 +26,16 @@ import com.google.gson.ToNumberStrategy;
 import com.google.gson.internal.LazilyParsedNumber;
 import com.google.gson.reflect.TypeToken;
 import com.google.gson.stream.JsonReader;
-import junit.framework.TestCase;
+import java.lang.reflect.Type;
+import java.math.BigDecimal;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.LinkedList;
+import java.util.List;
+import org.junit.Test;
 
-public class ToNumberPolicyFunctionalTest extends TestCase {
+public class ToNumberPolicyFunctionalTest {
+  @Test
   public void testDefault() {
     Gson gson = new Gson();
     assertEquals(null, gson.fromJson("null", Object.class));
@@ -40,6 +44,7 @@ public class ToNumberPolicyFunctionalTest extends TestCase {
     assertEquals(new LazilyParsedNumber("10"), gson.fromJson("10", Number.class));
   }
 
+  @Test
   public void testAsDoubles() {
     Gson gson = new GsonBuilder()
         .setObjectToNumberStrategy(ToNumberPolicy.DOUBLE)
@@ -51,6 +56,7 @@ public class ToNumberPolicyFunctionalTest extends TestCase {
     assertEquals(10.0, gson.fromJson("10", Number.class));
   }
 
+  @Test
   public void testAsLazilyParsedNumbers() {
     Gson gson = new GsonBuilder()
         .setObjectToNumberStrategy(ToNumberPolicy.LAZILY_PARSED_NUMBER)
@@ -62,6 +68,7 @@ public class ToNumberPolicyFunctionalTest extends TestCase {
     assertEquals(new LazilyParsedNumber("10"), gson.fromJson("10", Number.class));
   }
 
+  @Test
   public void testAsLongsOrDoubles() {
     Gson gson = new GsonBuilder()
         .setObjectToNumberStrategy(ToNumberPolicy.LONG_OR_DOUBLE)
@@ -75,6 +82,7 @@ public class ToNumberPolicyFunctionalTest extends TestCase {
     assertEquals(10.0, gson.fromJson("10.0", Number.class));
   }
 
+  @Test
   public void testAsBigDecimals() {
     Gson gson = new GsonBuilder()
         .setObjectToNumberStrategy(ToNumberPolicy.BIG_DECIMAL)
@@ -90,6 +98,7 @@ public class ToNumberPolicyFunctionalTest extends TestCase {
     assertEquals(new BigDecimal("1e400"), gson.fromJson("1e400", BigDecimal.class));
   }
 
+  @Test
   public void testAsListOfLongsOrDoubles() {
     Gson gson = new GsonBuilder()
         .setObjectToNumberStrategy(ToNumberPolicy.LONG_OR_DOUBLE)
@@ -107,6 +116,7 @@ public class ToNumberPolicyFunctionalTest extends TestCase {
     assertEquals(expected, numbers);
   }
 
+  @Test
   public void testCustomStrategiesCannotAffectConcreteDeclaredNumbers() {
     ToNumberStrategy fail = new ToNumberStrategy() {
       @Override
diff --git a/gson/src/test/java/com/google/gson/functional/TreeTypeAdaptersTest.java b/gson/src/test/java/com/google/gson/functional/TreeTypeAdaptersTest.java
index 2604c42e..3213a8e7 100644
--- a/gson/src/test/java/com/google/gson/functional/TreeTypeAdaptersTest.java
+++ b/gson/src/test/java/com/google/gson/functional/TreeTypeAdaptersTest.java
@@ -16,6 +16,9 @@
 
 package com.google.gson.functional;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
 import com.google.gson.JsonDeserializationContext;
@@ -31,12 +34,13 @@ import java.lang.reflect.Type;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
-import junit.framework.TestCase;
+import org.junit.Before;
+import org.junit.Test;
 
 /**
  * Collection of functional tests for DOM tree based type adapters.
  */
-public class TreeTypeAdaptersTest extends TestCase {
+public class TreeTypeAdaptersTest {
   private static final Id<Student> STUDENT1_ID = new Id<>("5", Student.class);
   private static final Id<Student> STUDENT2_ID = new Id<>("6", Student.class);
   private static final Student STUDENT1 = new Student(STUDENT1_ID, "first");
@@ -49,8 +53,8 @@ public class TreeTypeAdaptersTest extends TestCase {
   private Gson gson;
   private Course<HistoryCourse> course;
 
-  @Override
-  protected void setUp() {
+  @Before
+  public void setUp() {
     gson = new GsonBuilder()
         .setLenient()
         .registerTypeAdapter(Id.class, new IdTreeTypeAdapter())
@@ -59,6 +63,7 @@ public class TreeTypeAdaptersTest extends TestCase {
         new Assignment<HistoryCourse>(null, null), Arrays.asList(STUDENT1, STUDENT2));
   }
 
+  @Test
   public void testSerializeId() {
     String json = gson.toJson(course, TYPE_COURSE_HISTORY);
     assertTrue(json.contains(String.valueOf(COURSE_ID.getValue())));
@@ -66,6 +71,7 @@ public class TreeTypeAdaptersTest extends TestCase {
     assertTrue(json.contains(String.valueOf(STUDENT2_ID.getValue())));
   }
 
+  @Test
   public void testDeserializeId() {
     String json = "{courseId:1,students:[{id:1,name:'first'},{id:6,name:'second'}],"
       + "numAssignments:4,assignment:{}}";
diff --git a/gson/src/test/java/com/google/gson/functional/TypeAdapterPrecedenceTest.java b/gson/src/test/java/com/google/gson/functional/TypeAdapterPrecedenceTest.java
index c87d9f2d..e1993aa6 100644
--- a/gson/src/test/java/com/google/gson/functional/TypeAdapterPrecedenceTest.java
+++ b/gson/src/test/java/com/google/gson/functional/TypeAdapterPrecedenceTest.java
@@ -16,6 +16,8 @@
 
 package com.google.gson.functional;
 
+import static org.junit.Assert.assertEquals;
+
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
 import com.google.gson.JsonDeserializationContext;
@@ -29,9 +31,10 @@ import com.google.gson.stream.JsonReader;
 import com.google.gson.stream.JsonWriter;
 import java.io.IOException;
 import java.lang.reflect.Type;
-import junit.framework.TestCase;
+import org.junit.Test;
 
-public final class TypeAdapterPrecedenceTest extends TestCase {
+public final class TypeAdapterPrecedenceTest {
+  @Test
   public void testNonstreamingFollowedByNonstreaming() {
     Gson gson = new GsonBuilder()
         .setLenient()
@@ -44,6 +47,7 @@ public final class TypeAdapterPrecedenceTest extends TestCase {
     assertEquals("foo via deserializer 2", gson.fromJson("foo", Foo.class).name);
   }
 
+  @Test
   public void testStreamingFollowedByStreaming() {
     Gson gson = new GsonBuilder()
         .setLenient()
@@ -54,6 +58,7 @@ public final class TypeAdapterPrecedenceTest extends TestCase {
     assertEquals("foo via type adapter 2", gson.fromJson("foo", Foo.class).name);
   }
 
+  @Test
   public void testSerializeNonstreamingTypeAdapterFollowedByStreamingTypeAdapter() {
     Gson gson = new GsonBuilder()
         .setLenient()
@@ -65,6 +70,7 @@ public final class TypeAdapterPrecedenceTest extends TestCase {
     assertEquals("foo via type adapter", gson.fromJson("foo", Foo.class).name);
   }
 
+  @Test
   public void testStreamingFollowedByNonstreaming() {
     Gson gson = new GsonBuilder()
         .setLenient()
@@ -76,6 +82,7 @@ public final class TypeAdapterPrecedenceTest extends TestCase {
     assertEquals("foo via deserializer", gson.fromJson("foo", Foo.class).name);
   }
 
+  @Test
   public void testStreamingHierarchicalFollowedByNonstreaming() {
     Gson gson = new GsonBuilder()
         .setLenient()
@@ -87,6 +94,7 @@ public final class TypeAdapterPrecedenceTest extends TestCase {
     assertEquals("foo via deserializer", gson.fromJson("foo", Foo.class).name);
   }
 
+  @Test
   public void testStreamingFollowedByNonstreamingHierarchical() {
     Gson gson = new GsonBuilder()
         .registerTypeAdapter(Foo.class, newTypeAdapter("type adapter"))
@@ -97,6 +105,7 @@ public final class TypeAdapterPrecedenceTest extends TestCase {
     assertEquals("foo via type adapter", gson.fromJson("\"foo\"", Foo.class).name);
   }
 
+  @Test
   public void testStreamingHierarchicalFollowedByNonstreamingHierarchical() {
     Gson gson = new GsonBuilder()
         .setLenient()
@@ -108,6 +117,7 @@ public final class TypeAdapterPrecedenceTest extends TestCase {
     assertEquals("foo via type adapter", gson.fromJson("foo", Foo.class).name);
   }
 
+  @Test
   public void testNonstreamingHierarchicalFollowedByNonstreaming() {
     Gson gson = new GsonBuilder()
         .setLenient()
diff --git a/gson/src/test/java/com/google/gson/functional/TypeHierarchyAdapterTest.java b/gson/src/test/java/com/google/gson/functional/TypeHierarchyAdapterTest.java
index 25b9c343..e43fa5f7 100644
--- a/gson/src/test/java/com/google/gson/functional/TypeHierarchyAdapterTest.java
+++ b/gson/src/test/java/com/google/gson/functional/TypeHierarchyAdapterTest.java
@@ -16,6 +16,8 @@
 
 package com.google.gson.functional;
 
+import static org.junit.Assert.assertEquals;
+
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
 import com.google.gson.JsonDeserializationContext;
@@ -27,13 +29,14 @@ import com.google.gson.JsonPrimitive;
 import com.google.gson.JsonSerializationContext;
 import com.google.gson.JsonSerializer;
 import java.lang.reflect.Type;
-import junit.framework.TestCase;
+import org.junit.Test;
 
 /**
  * Test that the hierarchy adapter works when subtypes are used.
  */
-public final class TypeHierarchyAdapterTest extends TestCase {
+public final class TypeHierarchyAdapterTest {
 
+  @Test
   public void testTypeHierarchy() {
     Manager andy = new Manager();
     andy.userid = "andy";
@@ -116,6 +119,7 @@ public final class TypeHierarchyAdapterTest extends TestCase {
         ((Manager) company.ceo.minions[2]).minions[1].userid);
   }
 
+  @Test
   public void testRegisterSuperTypeFirst() {
     Gson gson = new GsonBuilder()
         .registerTypeHierarchyAdapter(Employee.class, new EmployeeAdapter())
@@ -132,6 +136,7 @@ public final class TypeHierarchyAdapterTest extends TestCase {
   }
 
   /** This behaviour changed in Gson 2.1; it used to throw. */
+  @Test
   public void testRegisterSubTypeFirstAllowed() {
     new GsonBuilder()
         .registerTypeHierarchyAdapter(Manager.class, new ManagerAdapter())
diff --git a/gson/src/test/java/com/google/gson/functional/TypeVariableTest.java b/gson/src/test/java/com/google/gson/functional/TypeVariableTest.java
index f9ef46b3..88b2d19d 100644
--- a/gson/src/test/java/com/google/gson/functional/TypeVariableTest.java
+++ b/gson/src/test/java/com/google/gson/functional/TypeVariableTest.java
@@ -15,6 +15,8 @@
  */
 package com.google.gson.functional;
 
+import static org.junit.Assert.assertEquals;
+
 import com.google.gson.Gson;
 import com.google.gson.reflect.TypeToken;
 import java.lang.reflect.Type;
@@ -23,7 +25,7 @@ import java.util.Arrays;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import junit.framework.TestCase;
+import org.junit.Test;
 
 /**
  * Functional test for Gson serialization and deserialization of
@@ -31,8 +33,9 @@ import junit.framework.TestCase;
  *
  * @author Joel Leitch
  */
-public class TypeVariableTest extends TestCase {
+public class TypeVariableTest {
 
+  @Test
   public void testAdvancedTypeVariables() throws Exception {
     Gson gson = new Gson();
     Bar bar1 = new Bar("someString", 1, true);
@@ -48,6 +51,7 @@ public class TypeVariableTest extends TestCase {
     assertEquals(bar1, bar2);
   }
 
+  @Test
   public void testTypeVariablesViaTypeParameter() throws Exception {
     Gson gson = new Gson();
     Foo<String, Integer> original = new Foo<>("e", 5, false);
@@ -59,6 +63,7 @@ public class TypeVariableTest extends TestCase {
     assertEquals(original, gson.<Foo<String, Integer>>fromJson(json, type));
   }
 
+  @Test
   public void testBasicTypeVariables() throws Exception {
     Gson gson = new Gson();
     Blue blue1 = new Blue(true);
diff --git a/gson/src/test/java/com/google/gson/functional/UncategorizedTest.java b/gson/src/test/java/com/google/gson/functional/UncategorizedTest.java
index 0ac03803..58171de0 100644
--- a/gson/src/test/java/com/google/gson/functional/UncategorizedTest.java
+++ b/gson/src/test/java/com/google/gson/functional/UncategorizedTest.java
@@ -15,6 +15,11 @@
  */
 package com.google.gson.functional;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
 import com.google.gson.JsonDeserializationContext;
@@ -23,13 +28,12 @@ import com.google.gson.JsonElement;
 import com.google.gson.JsonParseException;
 import com.google.gson.common.TestTypes.BagOfPrimitives;
 import com.google.gson.common.TestTypes.ClassOverridingEquals;
-
 import com.google.gson.reflect.TypeToken;
+import java.lang.reflect.Type;
 import java.util.Arrays;
 import java.util.List;
-import junit.framework.TestCase;
-
-import java.lang.reflect.Type;
+import org.junit.Before;
+import org.junit.Test;
 
 /**
  * Functional tests that do not fall neatly into any of the existing classification.
@@ -37,16 +41,16 @@ import java.lang.reflect.Type;
  * @author Inderjeet Singh
  * @author Joel Leitch
  */
-public class UncategorizedTest extends TestCase {
+public class UncategorizedTest {
 
   private Gson gson = null;
 
-  @Override
-  protected void setUp() throws Exception {
-    super.setUp();
+  @Before
+  public void setUp() throws Exception {
     gson = new Gson();
   }
 
+  @Test
   public void testInvalidJsonDeserializationFails() throws Exception {
     try {
       gson.fromJson("adfasdf1112,,,\":", BagOfPrimitives.class);
@@ -59,6 +63,7 @@ public class UncategorizedTest extends TestCase {
     } catch (JsonParseException expected) { }
   }
 
+  @Test
   public void testObjectEqualButNotSameSerialization() throws Exception {
     ClassOverridingEquals objA = new ClassOverridingEquals();
     ClassOverridingEquals objB = new ClassOverridingEquals();
@@ -67,11 +72,13 @@ public class UncategorizedTest extends TestCase {
     assertEquals(objB.getExpectedJson(), json);
   }
 
+  @Test
   public void testStaticFieldsAreNotSerialized() {
     BagOfPrimitives target = new BagOfPrimitives();
     assertFalse(gson.toJson(target).contains("DEFAULT_VALUE"));
   }
 
+  @Test
   public void testGsonInstanceReusableForSerializationAndDeserialization() {
     BagOfPrimitives bag = new BagOfPrimitives();
     String json = gson.toJson(bag);
@@ -84,6 +91,7 @@ public class UncategorizedTest extends TestCase {
    * base class object. For a motivation for this test, see Issue 37 and
    * http://groups.google.com/group/google-gson/browse_thread/thread/677d56e9976d7761
    */
+  @Test
   public void testReturningDerivedClassesDuringDeserialization() {
     Gson gson = new GsonBuilder().registerTypeAdapter(Base.class, new BaseTypeAdapter()).create();
     String json = "{\"opType\":\"OP1\"}";
@@ -101,6 +109,7 @@ public class UncategorizedTest extends TestCase {
    * Test that trailing whitespace is ignored.
    * http://code.google.com/p/google-gson/issues/detail?id=302
    */
+  @Test
   public void testTrailingWhitespace() throws Exception {
     List<Integer> integers = gson.fromJson("[1,2,3]  \n\n  ",
         new TypeToken<List<Integer>>() {}.getType());
diff --git a/gson/src/test/java/com/google/gson/internal/GsonTypesTest.java b/gson/src/test/java/com/google/gson/internal/GsonTypesTest.java
index c80700bd..dd45e87f 100644
--- a/gson/src/test/java/com/google/gson/internal/GsonTypesTest.java
+++ b/gson/src/test/java/com/google/gson/internal/GsonTypesTest.java
@@ -16,14 +16,18 @@
 
 package com.google.gson.internal;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.fail;
+
 import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.Type;
 import java.util.List;
+import org.junit.Test;
 
-import junit.framework.TestCase;
-
-public final class GsonTypesTest extends TestCase {
+public final class GsonTypesTest {
 
+  @Test
   public void testNewParameterizedTypeWithoutOwner() throws Exception {
     // List<A>. List is a top-level class
     Type type = $Gson$Types.newParameterizedTypeWithOwner(null, List.class, A.class);
@@ -46,6 +50,7 @@ public final class GsonTypesTest extends TestCase {
     assertEquals(D.class, getFirstTypeArgument(type));
   }
 
+  @Test
   public void testGetFirstTypeArgument() throws Exception {
     assertNull(getFirstTypeArgument(A.class));
 
diff --git a/gson/src/test/java/com/google/gson/internal/LazilyParsedNumberTest.java b/gson/src/test/java/com/google/gson/internal/LazilyParsedNumberTest.java
index 75e77bb5..f4f207f2 100644
--- a/gson/src/test/java/com/google/gson/internal/LazilyParsedNumberTest.java
+++ b/gson/src/test/java/com/google/gson/internal/LazilyParsedNumberTest.java
@@ -15,28 +15,33 @@
  */
 package com.google.gson.internal;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.ObjectInputStream;
 import java.io.ObjectOutputStream;
 import java.math.BigDecimal;
+import org.junit.Test;
 
-import junit.framework.TestCase;
-
-public class LazilyParsedNumberTest extends TestCase {
+public class LazilyParsedNumberTest {
+  @Test
   public void testHashCode() {
     LazilyParsedNumber n1 = new LazilyParsedNumber("1");
     LazilyParsedNumber n1Another = new LazilyParsedNumber("1");
     assertEquals(n1.hashCode(), n1Another.hashCode());
   }
 
+  @Test
   public void testEquals() {
     LazilyParsedNumber n1 = new LazilyParsedNumber("1");
     LazilyParsedNumber n1Another = new LazilyParsedNumber("1");
     assertTrue(n1.equals(n1Another));
   }
 
+  @Test
   public void testJavaSerialization() throws IOException, ClassNotFoundException {
     ByteArrayOutputStream out = new ByteArrayOutputStream();
     ObjectOutputStream objOut = new ObjectOutputStream(out);
diff --git a/gson/src/test/java/com/google/gson/internal/LinkedTreeMapTest.java b/gson/src/test/java/com/google/gson/internal/LinkedTreeMapTest.java
index 0b08d32e..89154ae4 100644
--- a/gson/src/test/java/com/google/gson/internal/LinkedTreeMapTest.java
+++ b/gson/src/test/java/com/google/gson/internal/LinkedTreeMapTest.java
@@ -16,6 +16,12 @@
 
 package com.google.gson.internal;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
 import com.google.gson.common.MoreAsserts;
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
@@ -29,10 +35,11 @@ import java.util.Iterator;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.Random;
-import junit.framework.TestCase;
+import org.junit.Test;
 
-public final class LinkedTreeMapTest extends TestCase {
+public final class LinkedTreeMapTest {
 
+  @Test
   public void testIterationOrder() {
     LinkedTreeMap<String, String> map = new LinkedTreeMap<>();
     map.put("a", "android");
@@ -42,6 +49,7 @@ public final class LinkedTreeMapTest extends TestCase {
     assertIterationOrder(map.values(), "android", "cola", "bbq");
   }
 
+  @Test
   public void testRemoveRootDoesNotDoubleUnlink() {
     LinkedTreeMap<String, String> map = new LinkedTreeMap<>();
     map.put("a", "android");
@@ -55,6 +63,7 @@ public final class LinkedTreeMapTest extends TestCase {
     assertIterationOrder(map.keySet(), "a", "c");
   }
 
+  @Test
   public void testPutNullKeyFails() {
     LinkedTreeMap<String, String> map = new LinkedTreeMap<>();
     try {
@@ -64,6 +73,7 @@ public final class LinkedTreeMapTest extends TestCase {
     }
   }
 
+  @Test
   public void testPutNonComparableKeyFails() {
     LinkedTreeMap<Object, String> map = new LinkedTreeMap<>();
     try {
@@ -72,6 +82,7 @@ public final class LinkedTreeMapTest extends TestCase {
     } catch (ClassCastException expected) {}
   }
 
+  @Test
   public void testPutNullValue() {
     LinkedTreeMap<String, String> map = new LinkedTreeMap<>();
     map.put("a", null);
@@ -81,6 +92,7 @@ public final class LinkedTreeMapTest extends TestCase {
     assertNull(map.get("a"));
   }
 
+  @Test
   public void testPutNullValue_Forbidden() {
     LinkedTreeMap<String, String> map = new LinkedTreeMap<>(false);
     try {
@@ -94,6 +106,7 @@ public final class LinkedTreeMapTest extends TestCase {
     assertFalse(map.containsValue(null));
   }
 
+  @Test
   public void testEntrySetValueNull() {
     LinkedTreeMap<String, String> map = new LinkedTreeMap<>();
     map.put("a", "1");
@@ -110,6 +123,7 @@ public final class LinkedTreeMapTest extends TestCase {
   }
 
 
+  @Test
   public void testEntrySetValueNull_Forbidden() {
     LinkedTreeMap<String, String> map = new LinkedTreeMap<>(false);
     map.put("a", "1");
@@ -125,12 +139,14 @@ public final class LinkedTreeMapTest extends TestCase {
     assertFalse(map.containsValue(null));
   }
 
+  @Test
   public void testContainsNonComparableKeyReturnsFalse() {
     LinkedTreeMap<String, String> map = new LinkedTreeMap<>();
     map.put("a", "android");
     assertFalse(map.containsKey(new Object()));
   }
 
+  @Test
   public void testContainsNullKeyIsAlwaysFalse() {
     LinkedTreeMap<String, String> map = new LinkedTreeMap<>();
     assertFalse(map.containsKey(null));
@@ -138,6 +154,7 @@ public final class LinkedTreeMapTest extends TestCase {
     assertFalse(map.containsKey(null));
   }
 
+  @Test
   public void testPutOverrides() throws Exception {
     LinkedTreeMap<String, String> map = new LinkedTreeMap<>();
     assertNull(map.put("d", "donut"));
@@ -150,6 +167,7 @@ public final class LinkedTreeMapTest extends TestCase {
     assertEquals(3, map.size());
   }
 
+  @Test
   public void testEmptyStringValues() {
     LinkedTreeMap<String, String> map = new LinkedTreeMap<>();
     map.put("a", "");
@@ -157,6 +175,7 @@ public final class LinkedTreeMapTest extends TestCase {
     assertEquals("", map.get("a"));
   }
 
+  @Test
   public void testLargeSetOfRandomKeys() throws Exception {
     Random random = new Random(1367593214724L);
     LinkedTreeMap<String, String> map = new LinkedTreeMap<>();
@@ -173,6 +192,7 @@ public final class LinkedTreeMapTest extends TestCase {
     }
   }
 
+  @Test
   public void testClear() {
     LinkedTreeMap<String, String> map = new LinkedTreeMap<>();
     map.put("a", "android");
@@ -183,6 +203,7 @@ public final class LinkedTreeMapTest extends TestCase {
     assertEquals(0, map.size());
   }
 
+  @Test
   public void testEqualsAndHashCode() throws Exception {
     LinkedTreeMap<String, Integer> map1 = new LinkedTreeMap<>();
     map1.put("A", 1);
@@ -199,6 +220,7 @@ public final class LinkedTreeMapTest extends TestCase {
     MoreAsserts.assertEqualsAndHashCode(map1, map2);
   }
 
+  @Test
   public void testJavaSerialization() throws IOException, ClassNotFoundException {
     ByteArrayOutputStream out = new ByteArrayOutputStream();
     ObjectOutputStream objOut = new ObjectOutputStream(out);
diff --git a/gson/src/test/java/com/google/gson/internal/UnsafeAllocatorInstantiationTest.java b/gson/src/test/java/com/google/gson/internal/UnsafeAllocatorInstantiationTest.java
index 54d0a506..b8ab177d 100644
--- a/gson/src/test/java/com/google/gson/internal/UnsafeAllocatorInstantiationTest.java
+++ b/gson/src/test/java/com/google/gson/internal/UnsafeAllocatorInstantiationTest.java
@@ -15,13 +15,17 @@
  */
 package com.google.gson.internal;
 
-import junit.framework.TestCase;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import org.junit.Test;
 
 /**
  * Test unsafe allocator instantiation
  * @author Ugljesa Jovanovic
  */
-public final class UnsafeAllocatorInstantiationTest extends TestCase {
+public final class UnsafeAllocatorInstantiationTest {
 
   public interface Interface {
   }
@@ -36,6 +40,7 @@ public final class UnsafeAllocatorInstantiationTest extends TestCase {
    * Ensure that an {@link AssertionError} is thrown when trying
    * to instantiate an interface
    */
+  @Test
   public void testInterfaceInstantiation() throws Exception {
     try {
       UnsafeAllocator.INSTANCE.newInstance(Interface.class);
@@ -49,6 +54,7 @@ public final class UnsafeAllocatorInstantiationTest extends TestCase {
    * Ensure that an {@link AssertionError} is thrown when trying
    * to instantiate an abstract class
    */
+  @Test
   public void testAbstractClassInstantiation() throws Exception {
     try {
       UnsafeAllocator.INSTANCE.newInstance(AbstractClass.class);
@@ -61,6 +67,7 @@ public final class UnsafeAllocatorInstantiationTest extends TestCase {
   /**
    * Ensure that no exception is thrown when trying to instantiate a concrete class
    */
+  @Test
   public void testConcreteClassInstantiation() throws Exception {
     ConcreteClass instance = UnsafeAllocator.INSTANCE.newInstance(ConcreteClass.class);
     assertNotNull(instance);
diff --git a/gson/src/test/java/com/google/gson/internal/bind/DefaultDateTypeAdapterTest.java b/gson/src/test/java/com/google/gson/internal/bind/DefaultDateTypeAdapterTest.java
index c20a3683..d006eb09 100644
--- a/gson/src/test/java/com/google/gson/internal/bind/DefaultDateTypeAdapterTest.java
+++ b/gson/src/test/java/com/google/gson/internal/bind/DefaultDateTypeAdapterTest.java
@@ -16,31 +16,38 @@
 
 package com.google.gson.internal.bind;
 
-import java.io.IOException;
-import java.text.DateFormat;
-import java.text.SimpleDateFormat;
-import java.util.Date;
-import java.util.Locale;
-import java.util.TimeZone;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.fail;
+
 import com.google.gson.Gson;
 import com.google.gson.TypeAdapter;
 import com.google.gson.TypeAdapterFactory;
 import com.google.gson.internal.JavaVersion;
 import com.google.gson.internal.bind.DefaultDateTypeAdapter.DateType;
 import com.google.gson.reflect.TypeToken;
-import junit.framework.TestCase;
+import java.io.IOException;
+import java.text.DateFormat;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.Locale;
+import java.util.TimeZone;
+import org.junit.Test;
 
 /**
  * A simple unit test for the {@link DefaultDateTypeAdapter} class.
  *
  * @author Joel Leitch
  */
-public class DefaultDateTypeAdapterTest extends TestCase {
+public class DefaultDateTypeAdapterTest {
 
+  @Test
   public void testFormattingInEnUs() {
     assertFormattingAlwaysEmitsUsLocale(Locale.US);
   }
 
+  @Test
   public void testFormattingInFr() {
     assertFormattingAlwaysEmitsUsLocale(Locale.FRANCE);
   }
@@ -73,32 +80,37 @@ public class DefaultDateTypeAdapterTest extends TestCase {
     }
   }
 
+  @Test
   public void testParsingDatesFormattedWithSystemLocale() throws Exception {
-    // TODO(eamonnmcmanus): fix this test, which fails on JDK 8 and 17
-    if (JavaVersion.getMajorJavaVersion() != 11) {
-      return;
-    }
     TimeZone defaultTimeZone = TimeZone.getDefault();
     TimeZone.setDefault(TimeZone.getTimeZone("UTC"));
     Locale defaultLocale = Locale.getDefault();
     Locale.setDefault(Locale.FRANCE);
     try {
-      String afterYearSep = JavaVersion.isJava9OrLater() ? " à " : " ";
-      assertParsed(String.format("1 janv. 1970%s00:00:00", afterYearSep),
+      Date date = new Date(0);
+      assertParsed(
+          DateFormat.getDateTimeInstance(DateFormat.MEDIUM, DateFormat.MEDIUM).format(date),
           DateType.DATE.createDefaultsAdapterFactory());
-      assertParsed("01/01/70", DateType.DATE.createAdapterFactory(DateFormat.SHORT));
-      assertParsed("1 janv. 1970", DateType.DATE.createAdapterFactory(DateFormat.MEDIUM));
-      assertParsed("1 janvier 1970", DateType.DATE.createAdapterFactory(DateFormat.LONG));
-      assertParsed("01/01/70 00:00",
+      assertParsed(
+          DateFormat.getDateInstance(DateFormat.SHORT).format(date),
+          DateType.DATE.createAdapterFactory(DateFormat.SHORT));
+      assertParsed(
+          DateFormat.getDateInstance(DateFormat.MEDIUM).format(date),
+          DateType.DATE.createAdapterFactory(DateFormat.MEDIUM));
+      assertParsed(
+          DateFormat.getDateInstance(DateFormat.LONG).format(date),
+          DateType.DATE.createAdapterFactory(DateFormat.LONG));
+      assertParsed(
+          DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.SHORT).format(date),
           DateType.DATE.createAdapterFactory(DateFormat.SHORT, DateFormat.SHORT));
-      assertParsed(String.format("1 janv. 1970%s00:00:00", afterYearSep),
+      assertParsed(
+          DateFormat.getDateTimeInstance(DateFormat.MEDIUM, DateFormat.MEDIUM).format(date),
           DateType.DATE.createAdapterFactory(DateFormat.MEDIUM, DateFormat.MEDIUM));
-      assertParsed(String.format("1 janvier 1970%s00:00:00 UTC", afterYearSep),
+      assertParsed(
+          DateFormat.getDateTimeInstance(DateFormat.LONG, DateFormat.LONG).format(date),
           DateType.DATE.createAdapterFactory(DateFormat.LONG, DateFormat.LONG));
-      assertParsed(JavaVersion.isJava9OrLater() ? (JavaVersion.getMajorJavaVersion() <11 ?
-                      "jeudi 1 janvier 1970 à 00:00:00 Coordinated Universal Time" :
-                      "jeudi 1 janvier 1970 à 00:00:00 Temps universel coordonné") :
-                      "jeudi 1 janvier 1970 00 h 00 UTC",
+      assertParsed(
+          DateFormat.getDateTimeInstance(DateFormat.FULL, DateFormat.FULL).format(date),
           DateType.DATE.createAdapterFactory(DateFormat.FULL, DateFormat.FULL));
     } finally {
       TimeZone.setDefault(defaultTimeZone);
@@ -106,6 +118,7 @@ public class DefaultDateTypeAdapterTest extends TestCase {
     }
   }
 
+  @Test
   public void testParsingDatesFormattedWithUsLocale() throws Exception {
     TimeZone defaultTimeZone = TimeZone.getDefault();
     TimeZone.setDefault(TimeZone.getTimeZone("UTC"));
@@ -130,6 +143,7 @@ public class DefaultDateTypeAdapterTest extends TestCase {
     }
   }
 
+  @Test
   public void testFormatUsesDefaultTimezone() throws Exception {
     TimeZone defaultTimeZone = TimeZone.getDefault();
     TimeZone.setDefault(TimeZone.getTimeZone("America/Los_Angeles"));
@@ -146,6 +160,7 @@ public class DefaultDateTypeAdapterTest extends TestCase {
     }
   }
 
+  @Test
   public void testDateDeserializationISO8601() throws Exception {
     TypeAdapterFactory adapterFactory = DateType.DATE.createDefaultsAdapterFactory();
     assertParsed("1970-01-01T00:00:00.000Z", adapterFactory);
@@ -155,6 +170,7 @@ public class DefaultDateTypeAdapterTest extends TestCase {
     assertParsed("1970-01-01T01:00:00+01", adapterFactory);
   }
 
+  @Test
   public void testDateSerialization() throws Exception {
     int dateStyle = DateFormat.LONG;
     TypeAdapter<Date> dateTypeAdapter = dateAdapter(DateType.DATE.createAdapterFactory(dateStyle));
@@ -165,6 +181,7 @@ public class DefaultDateTypeAdapterTest extends TestCase {
     assertEquals(toLiteral(formatter.format(currentDate)), dateString);
   }
 
+  @Test
   public void testDatePattern() throws Exception {
     String pattern = "yyyy-MM-dd";
     TypeAdapter<Date> dateTypeAdapter = dateAdapter(DateType.DATE.createAdapterFactory(pattern));
@@ -175,6 +192,7 @@ public class DefaultDateTypeAdapterTest extends TestCase {
     assertEquals(toLiteral(formatter.format(currentDate)), dateString);
   }
 
+  @Test
   public void testInvalidDatePattern() throws Exception {
     try {
       DateType.DATE.createAdapterFactory("I am a bad Date pattern....");
@@ -182,12 +200,14 @@ public class DefaultDateTypeAdapterTest extends TestCase {
     } catch (IllegalArgumentException expected) { }
   }
 
+  @Test
   public void testNullValue() throws Exception {
     TypeAdapter<Date> adapter = dateAdapter(DateType.DATE.createDefaultsAdapterFactory());
     assertNull(adapter.fromJson("null"));
     assertEquals("null", adapter.toJson(null));
   }
 
+  @Test
   public void testUnexpectedToken() throws Exception {
     try {
       TypeAdapter<Date> adapter = dateAdapter(DateType.DATE.createDefaultsAdapterFactory());
diff --git a/gson/src/test/java/com/google/gson/internal/bind/JsonElementReaderTest.java b/gson/src/test/java/com/google/gson/internal/bind/JsonElementReaderTest.java
index b8e5f623..efdf7b63 100644
--- a/gson/src/test/java/com/google/gson/internal/bind/JsonElementReaderTest.java
+++ b/gson/src/test/java/com/google/gson/internal/bind/JsonElementReaderTest.java
@@ -16,38 +16,45 @@
 
 package com.google.gson.internal.bind;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
 import com.google.gson.JsonElement;
 import com.google.gson.JsonParser;
 import com.google.gson.JsonPrimitive;
 import com.google.gson.stream.JsonToken;
 import com.google.gson.stream.MalformedJsonException;
 import java.io.IOException;
-import junit.framework.TestCase;
+import org.junit.Test;
 
 @SuppressWarnings("resource")
-public final class JsonElementReaderTest extends TestCase {
+public final class JsonElementReaderTest {
 
+  @Test
   public void testNumbers() throws IOException {
     JsonElement element = JsonParser.parseString("[1, 2, 3]");
     JsonTreeReader reader = new JsonTreeReader(element);
     reader.beginArray();
     assertEquals(1, reader.nextInt());
     assertEquals(2L, reader.nextLong());
-    assertEquals(3.0, reader.nextDouble());
+    assertEquals(3.0, reader.nextDouble(), 0);
     reader.endArray();
   }
 
+  @Test
   public void testLenientNansAndInfinities() throws IOException {
     JsonElement element = JsonParser.parseString("[NaN, -Infinity, Infinity]");
     JsonTreeReader reader = new JsonTreeReader(element);
     reader.setLenient(true);
     reader.beginArray();
     assertTrue(Double.isNaN(reader.nextDouble()));
-    assertEquals(Double.NEGATIVE_INFINITY, reader.nextDouble());
-    assertEquals(Double.POSITIVE_INFINITY, reader.nextDouble());
+    assertEquals(Double.NEGATIVE_INFINITY, reader.nextDouble(), 0);
+    assertEquals(Double.POSITIVE_INFINITY, reader.nextDouble(), 0);
     reader.endArray();
   }
 
+  @Test
   public void testStrictNansAndInfinities() throws IOException {
     JsonElement element = JsonParser.parseString("[NaN, -Infinity, Infinity]");
     JsonTreeReader reader = new JsonTreeReader(element);
@@ -77,16 +84,18 @@ public final class JsonElementReaderTest extends TestCase {
     reader.endArray();
   }
 
+  @Test
   public void testNumbersFromStrings() throws IOException {
     JsonElement element = JsonParser.parseString("[\"1\", \"2\", \"3\"]");
     JsonTreeReader reader = new JsonTreeReader(element);
     reader.beginArray();
     assertEquals(1, reader.nextInt());
     assertEquals(2L, reader.nextLong());
-    assertEquals(3.0, reader.nextDouble());
+    assertEquals(3.0, reader.nextDouble(), 0);
     reader.endArray();
   }
 
+  @Test
   public void testStringsFromNumbers() throws IOException {
     JsonElement element = JsonParser.parseString("[1]");
     JsonTreeReader reader = new JsonTreeReader(element);
@@ -95,6 +104,7 @@ public final class JsonElementReaderTest extends TestCase {
     reader.endArray();
   }
 
+  @Test
   public void testBooleans() throws IOException {
     JsonElement element = JsonParser.parseString("[true, false]");
     JsonTreeReader reader = new JsonTreeReader(element);
@@ -104,6 +114,7 @@ public final class JsonElementReaderTest extends TestCase {
     reader.endArray();
   }
 
+  @Test
   public void testNulls() throws IOException {
     JsonElement element = JsonParser.parseString("[null,null]");
     JsonTreeReader reader = new JsonTreeReader(element);
@@ -113,6 +124,7 @@ public final class JsonElementReaderTest extends TestCase {
     reader.endArray();
   }
 
+  @Test
   public void testStrings() throws IOException {
     JsonElement element = JsonParser.parseString("[\"A\",\"B\"]");
     JsonTreeReader reader = new JsonTreeReader(element);
@@ -122,6 +134,7 @@ public final class JsonElementReaderTest extends TestCase {
     reader.endArray();
   }
 
+  @Test
   public void testArray() throws IOException {
     JsonElement element = JsonParser.parseString("[1, 2, 3]");
     JsonTreeReader reader = new JsonTreeReader(element);
@@ -138,6 +151,7 @@ public final class JsonElementReaderTest extends TestCase {
     assertEquals(JsonToken.END_DOCUMENT, reader.peek());
   }
 
+  @Test
   public void testObject() throws IOException {
     JsonElement element = JsonParser.parseString("{\"A\": 1, \"B\": 2}");
     JsonTreeReader reader = new JsonTreeReader(element);
@@ -156,6 +170,7 @@ public final class JsonElementReaderTest extends TestCase {
     assertEquals(JsonToken.END_DOCUMENT, reader.peek());
   }
 
+  @Test
   public void testEmptyArray() throws IOException {
     JsonElement element = JsonParser.parseString("[]");
     JsonTreeReader reader = new JsonTreeReader(element);
@@ -163,6 +178,7 @@ public final class JsonElementReaderTest extends TestCase {
     reader.endArray();
   }
 
+  @Test
   public void testNestedArrays() throws IOException {
     JsonElement element = JsonParser.parseString("[[],[[]]]");
     JsonTreeReader reader = new JsonTreeReader(element);
@@ -176,6 +192,7 @@ public final class JsonElementReaderTest extends TestCase {
     reader.endArray();
   }
 
+  @Test
   public void testNestedObjects() throws IOException {
     JsonElement element = JsonParser.parseString("{\"A\":{},\"B\":{\"C\":{}}}");
     JsonTreeReader reader = new JsonTreeReader(element);
@@ -192,6 +209,7 @@ public final class JsonElementReaderTest extends TestCase {
     reader.endObject();
   }
 
+  @Test
   public void testEmptyObject() throws IOException {
     JsonElement element = JsonParser.parseString("{}");
     JsonTreeReader reader = new JsonTreeReader(element);
@@ -199,6 +217,7 @@ public final class JsonElementReaderTest extends TestCase {
     reader.endObject();
   }
 
+  @Test
   public void testSkipValue() throws IOException {
     JsonElement element = JsonParser.parseString("[\"A\",{\"B\":[[]]},\"C\",[[]],\"D\",null]");
     JsonTreeReader reader = new JsonTreeReader(element);
@@ -212,6 +231,7 @@ public final class JsonElementReaderTest extends TestCase {
     reader.endArray();
   }
 
+  @Test
   public void testWrongType() throws IOException {
     JsonElement element = JsonParser.parseString("[[],\"A\"]");
     JsonTreeReader reader = new JsonTreeReader(element);
@@ -303,6 +323,7 @@ public final class JsonElementReaderTest extends TestCase {
     reader.endArray();
   }
 
+  @Test
   public void testNextJsonElement() throws IOException {
     final JsonElement element = JsonParser.parseString("{\"A\": 1, \"B\" : {}, \"C\" : []}");
     JsonTreeReader reader = new JsonTreeReader(element);
@@ -338,6 +359,7 @@ public final class JsonElementReaderTest extends TestCase {
     }
   }
 
+  @Test
   public void testEarlyClose() throws IOException {
     JsonElement element = JsonParser.parseString("[1, 2, 3]");
     JsonTreeReader reader = new JsonTreeReader(element);
diff --git a/gson/src/test/java/com/google/gson/internal/bind/JsonTreeReaderTest.java b/gson/src/test/java/com/google/gson/internal/bind/JsonTreeReaderTest.java
index 2ac32a0e..0c40b001 100644
--- a/gson/src/test/java/com/google/gson/internal/bind/JsonTreeReaderTest.java
+++ b/gson/src/test/java/com/google/gson/internal/bind/JsonTreeReaderTest.java
@@ -15,6 +15,10 @@
  */
 package com.google.gson.internal.bind;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.fail;
+
 import com.google.gson.JsonArray;
 import com.google.gson.JsonElement;
 import com.google.gson.JsonNull;
@@ -27,12 +31,13 @@ import java.io.IOException;
 import java.io.Reader;
 import java.util.Arrays;
 import java.util.List;
-import junit.framework.TestCase;
+import org.junit.Test;
 
 import static org.junit.Assert.assertThrows;
 
 @SuppressWarnings("resource")
-public class JsonTreeReaderTest extends TestCase {
+public class JsonTreeReaderTest {
+  @Test
   public void testSkipValue_emptyJsonObject() throws IOException {
     JsonTreeReader in = new JsonTreeReader(new JsonObject());
     in.skipValue();
@@ -40,6 +45,7 @@ public class JsonTreeReaderTest extends TestCase {
     assertEquals("$", in.getPath());
   }
 
+  @Test
   public void testSkipValue_filledJsonObject() throws IOException {
     JsonObject jsonObject = new JsonObject();
     JsonArray jsonArray = new JsonArray();
@@ -59,6 +65,7 @@ public class JsonTreeReaderTest extends TestCase {
     assertEquals("$", in.getPath());
   }
 
+  @Test
   public void testSkipValue_name() throws IOException {
     JsonObject jsonObject = new JsonObject();
     jsonObject.addProperty("a", "value");
@@ -70,6 +77,7 @@ public class JsonTreeReaderTest extends TestCase {
     assertEquals("value", in.nextString());
   }
 
+  @Test
   public void testSkipValue_afterEndOfDocument() throws IOException {
     JsonTreeReader reader = new JsonTreeReader(new JsonObject());
     reader.beginObject();
@@ -82,6 +90,7 @@ public class JsonTreeReaderTest extends TestCase {
     assertEquals("$", reader.getPath());
   }
 
+  @Test
   public void testSkipValue_atArrayEnd() throws IOException {
     JsonTreeReader reader = new JsonTreeReader(new JsonArray());
     reader.beginArray();
@@ -90,6 +99,7 @@ public class JsonTreeReaderTest extends TestCase {
     assertEquals("$", reader.getPath());
   }
 
+  @Test
   public void testSkipValue_atObjectEnd() throws IOException {
     JsonTreeReader reader = new JsonTreeReader(new JsonObject());
     reader.beginObject();
@@ -98,6 +108,7 @@ public class JsonTreeReaderTest extends TestCase {
     assertEquals("$", reader.getPath());
   }
 
+  @Test
   public void testHasNext_endOfDocument() throws IOException {
     JsonTreeReader reader = new JsonTreeReader(new JsonObject());
     reader.beginObject();
@@ -105,6 +116,7 @@ public class JsonTreeReaderTest extends TestCase {
     assertFalse(reader.hasNext());
   }
 
+  @Test
   public void testCustomJsonElementSubclass() throws IOException {
     @SuppressWarnings("deprecation") // superclass constructor
     class CustomSubclass extends JsonElement {
@@ -134,6 +146,7 @@ public class JsonTreeReaderTest extends TestCase {
    * read from a {@link JsonElement} instead of a {@link Reader}. Therefore all relevant methods of
    * {@code JsonReader} must be overridden.
    */
+  @Test
   public void testOverrides() {
     List<String> ignoredMethods = Arrays.asList("setLenient(boolean)", "isLenient()",
             "setSerializeSpecialFloatingPointValues(boolean)", "isSerializeSpecialFloatingPointValues()");
diff --git a/gson/src/test/java/com/google/gson/internal/bind/JsonTreeWriterTest.java b/gson/src/test/java/com/google/gson/internal/bind/JsonTreeWriterTest.java
index 19e30f34..d64b73f6 100644
--- a/gson/src/test/java/com/google/gson/internal/bind/JsonTreeWriterTest.java
+++ b/gson/src/test/java/com/google/gson/internal/bind/JsonTreeWriterTest.java
@@ -16,6 +16,9 @@
 
 package com.google.gson.internal.bind;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
 import com.google.gson.JsonElement;
 import com.google.gson.JsonNull;
 import com.google.gson.common.MoreAsserts;
@@ -24,10 +27,11 @@ import java.io.IOException;
 import java.io.Writer;
 import java.util.Arrays;
 import java.util.List;
-import junit.framework.TestCase;
+import org.junit.Test;
 
 @SuppressWarnings("resource")
-public final class JsonTreeWriterTest extends TestCase {
+public final class JsonTreeWriterTest {
+  @Test
   public void testArray() throws IOException {
     JsonTreeWriter writer = new JsonTreeWriter();
     writer.beginArray();
@@ -38,6 +42,7 @@ public final class JsonTreeWriterTest extends TestCase {
     assertEquals("[1,2,3]", writer.get().toString());
   }
 
+  @Test
   public void testNestedArray() throws IOException {
     JsonTreeWriter writer = new JsonTreeWriter();
     writer.beginArray();
@@ -51,6 +56,7 @@ public final class JsonTreeWriterTest extends TestCase {
     assertEquals("[[],[[]]]", writer.get().toString());
   }
 
+  @Test
   public void testObject() throws IOException {
     JsonTreeWriter writer = new JsonTreeWriter();
     writer.beginObject();
@@ -60,6 +66,7 @@ public final class JsonTreeWriterTest extends TestCase {
     assertEquals("{\"A\":1,\"B\":2}", writer.get().toString());
   }
 
+  @Test
   public void testNestedObject() throws IOException {
     JsonTreeWriter writer = new JsonTreeWriter();
     writer.beginObject();
@@ -76,6 +83,7 @@ public final class JsonTreeWriterTest extends TestCase {
     assertEquals("{\"A\":{\"B\":{}},\"C\":{}}", writer.get().toString());
   }
 
+  @Test
   public void testWriteAfterClose() throws Exception {
     JsonTreeWriter writer = new JsonTreeWriter();
     writer.setLenient(true);
@@ -90,6 +98,7 @@ public final class JsonTreeWriterTest extends TestCase {
     }
   }
 
+  @Test
   public void testPrematureClose() throws Exception {
     JsonTreeWriter writer = new JsonTreeWriter();
     writer.setLenient(true);
@@ -101,6 +110,7 @@ public final class JsonTreeWriterTest extends TestCase {
     }
   }
 
+  @Test
   public void testSerializeNullsFalse() throws IOException {
     JsonTreeWriter writer = new JsonTreeWriter();
     writer.setSerializeNulls(false);
@@ -111,6 +121,7 @@ public final class JsonTreeWriterTest extends TestCase {
     assertEquals("{}", writer.get().toString());
   }
 
+  @Test
   public void testSerializeNullsTrue() throws IOException {
     JsonTreeWriter writer = new JsonTreeWriter();
     writer.setSerializeNulls(true);
@@ -121,39 +132,46 @@ public final class JsonTreeWriterTest extends TestCase {
     assertEquals("{\"A\":null}", writer.get().toString());
   }
 
+  @Test
   public void testEmptyWriter() {
     JsonTreeWriter writer = new JsonTreeWriter();
     assertEquals(JsonNull.INSTANCE, writer.get());
   }
 
+  @Test
   public void testBeginArray() throws Exception {
     JsonTreeWriter writer = new JsonTreeWriter();
     assertEquals(writer, writer.beginArray());
   }
 
+  @Test
   public void testBeginObject() throws Exception {
     JsonTreeWriter writer = new JsonTreeWriter();
     assertEquals(writer, writer.beginObject());
   }
 
+  @Test
   public void testValueString() throws Exception {
     JsonTreeWriter writer = new JsonTreeWriter();
     String n = "as";
     assertEquals(writer, writer.value(n));
   }
 
+  @Test
   public void testBoolValue() throws Exception {
     JsonTreeWriter writer = new JsonTreeWriter();
     boolean bool = true;
     assertEquals(writer, writer.value(bool));
   }
 
+  @Test
   public void testBoolMaisValue() throws Exception {
     JsonTreeWriter writer = new JsonTreeWriter();
     Boolean bool = true;
     assertEquals(writer, writer.value(bool));
   }
 
+  @Test
   public void testLenientNansAndInfinities() throws IOException {
     JsonTreeWriter writer = new JsonTreeWriter();
     writer.setLenient(true);
@@ -168,6 +186,7 @@ public final class JsonTreeWriterTest extends TestCase {
     assertEquals("[NaN,-Infinity,Infinity,NaN,-Infinity,Infinity]", writer.get().toString());
   }
 
+  @Test
   public void testStrictNansAndInfinities() throws IOException {
     JsonTreeWriter writer = new JsonTreeWriter();
     writer.setLenient(false);
@@ -204,6 +223,7 @@ public final class JsonTreeWriterTest extends TestCase {
     }
   }
 
+  @Test
   public void testStrictBoxedNansAndInfinities() throws IOException {
     JsonTreeWriter writer = new JsonTreeWriter();
     writer.setLenient(false);
@@ -240,6 +260,7 @@ public final class JsonTreeWriterTest extends TestCase {
     }
   }
 
+  @Test
   public void testJsonValue() throws IOException {
     JsonTreeWriter writer = new JsonTreeWriter();
     writer.beginArray();
@@ -255,6 +276,7 @@ public final class JsonTreeWriterTest extends TestCase {
    * create a {@link JsonElement} tree instead of writing to a {@link Writer}. Therefore all relevant
    * methods of {@code JsonWriter} must be overridden.
    */
+  @Test
   public void testOverrides() {
     List<String> ignoredMethods = Arrays.asList("setLenient(boolean)", "isLenient()",
             "setSerializeSpecialFloatingPointValues(boolean)", "isSerializeSpecialFloatingPointValues()",
diff --git a/gson/src/test/java/com/google/gson/internal/bind/RecursiveTypesResolveTest.java b/gson/src/test/java/com/google/gson/internal/bind/RecursiveTypesResolveTest.java
index ca068df3..9959360d 100644
--- a/gson/src/test/java/com/google/gson/internal/bind/RecursiveTypesResolveTest.java
+++ b/gson/src/test/java/com/google/gson/internal/bind/RecursiveTypesResolveTest.java
@@ -16,10 +16,13 @@
 
 package com.google.gson.internal.bind;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
 import com.google.gson.Gson;
 import com.google.gson.TypeAdapter;
 import com.google.gson.internal.$Gson$Types;
-import junit.framework.TestCase;
+import org.junit.Test;
 
 /**
  * Test fixes for infinite recursion on {@link $Gson$Types#resolve(java.lang.reflect.Type, Class,
@@ -29,7 +32,7 @@ import junit.framework.TestCase;
  * These tests originally caused {@link StackOverflowError} because of infinite recursion on attempts to
  * resolve generics on types, with an intermediate types like 'Foo2&lt;? extends ? super ? extends ... ? extends A&gt;'
  */
-public class RecursiveTypesResolveTest extends TestCase {
+public class RecursiveTypesResolveTest {
 
   @SuppressWarnings("unused")
   private static class Foo1<A> {
@@ -44,6 +47,7 @@ public class RecursiveTypesResolveTest extends TestCase {
    * Test simplest case of recursion.
    */
 
+  @Test
   public void testRecursiveResolveSimple() {
     @SuppressWarnings("rawtypes")
     TypeAdapter<Foo1> adapter = new Gson().getAdapter(Foo1.class);
@@ -54,21 +58,25 @@ public class RecursiveTypesResolveTest extends TestCase {
    * Tests belows check the behaviour of the methods changed for the fix.
    */
 
+  @Test
   public void testDoubleSupertype() {
     assertEquals($Gson$Types.supertypeOf(Number.class),
             $Gson$Types.supertypeOf($Gson$Types.supertypeOf(Number.class)));
   }
 
+  @Test
   public void testDoubleSubtype() {
     assertEquals($Gson$Types.subtypeOf(Number.class),
             $Gson$Types.subtypeOf($Gson$Types.subtypeOf(Number.class)));
   }
 
+  @Test
   public void testSuperSubtype() {
     assertEquals($Gson$Types.subtypeOf(Object.class),
             $Gson$Types.supertypeOf($Gson$Types.subtypeOf(Number.class)));
   }
 
+  @Test
   public void testSubSupertype() {
     assertEquals($Gson$Types.subtypeOf(Object.class),
             $Gson$Types.subtypeOf($Gson$Types.supertypeOf(Number.class)));
@@ -88,12 +96,14 @@ public class RecursiveTypesResolveTest extends TestCase {
     TestType2<? super Y, ? super X> superReversedType;
   }
 
+  @Test
   public void testRecursiveTypeVariablesResolve1() throws Exception {
     @SuppressWarnings("rawtypes")
     TypeAdapter<TestType> adapter = new Gson().getAdapter(TestType.class);
     assertNotNull(adapter);
   }
 
+  @Test
   public void testRecursiveTypeVariablesResolve12() throws Exception {
     @SuppressWarnings("rawtypes")
     TypeAdapter<TestType2> adapter = new Gson().getAdapter(TestType2.class);
diff --git a/gson/src/test/java/com/google/gson/internal/bind/util/ISO8601UtilsTest.java b/gson/src/test/java/com/google/gson/internal/bind/util/ISO8601UtilsTest.java
index 68db238a..4c162946 100644
--- a/gson/src/test/java/com/google/gson/internal/bind/util/ISO8601UtilsTest.java
+++ b/gson/src/test/java/com/google/gson/internal/bind/util/ISO8601UtilsTest.java
@@ -28,8 +28,8 @@ public class ISO8601UtilsTest {
         return calendar;
     }
 
-    @Test
-    public void testDateFormatString() {
+  @Test
+  public void testDateFormatString() {
         GregorianCalendar calendar = new GregorianCalendar(utcTimeZone(), Locale.US);
         // Calendar was created with current time, must clear it
         calendar.clear();
@@ -40,8 +40,8 @@ public class ISO8601UtilsTest {
         assertEquals(expectedDate, dateStr.substring(0, expectedDate.length()));
     }
 
-    @Test
-    public void testDateFormatWithMilliseconds() {
+  @Test
+  public void testDateFormatWithMilliseconds() {
         long time = 1530209176870L;
         Date date = new Date(time);
         String dateStr = ISO8601Utils.format(date, true);
@@ -49,8 +49,8 @@ public class ISO8601UtilsTest {
         assertEquals(expectedDate, dateStr);
     }
 
-    @Test
-    public void testDateFormatWithTimezone() {
+  @Test
+  public void testDateFormatWithTimezone() {
         long time = 1530209176870L;
         Date date = new Date(time);
         String dateStr = ISO8601Utils.format(date, true, TimeZone.getTimeZone("Brazil/East"));
@@ -58,16 +58,16 @@ public class ISO8601UtilsTest {
         assertEquals(expectedDate, dateStr);
     }
 
-    @Test
-    public void testDateParseWithDefaultTimezone() throws ParseException {
+  @Test
+  public void testDateParseWithDefaultTimezone() throws ParseException {
         String dateStr = "2018-06-25";
         Date date = ISO8601Utils.parse(dateStr, new ParsePosition(0));
         Date expectedDate = new GregorianCalendar(2018, Calendar.JUNE, 25).getTime();
         assertEquals(expectedDate, date);
     }
 
-    @Test
-    public void testDateParseInvalidDay() {
+  @Test
+  public void testDateParseInvalidDay() {
       String dateStr = "2022-12-33";
       try {
         ISO8601Utils.parse(dateStr, new ParsePosition(0));
@@ -76,8 +76,8 @@ public class ISO8601UtilsTest {
       }
     }
 
-    @Test
-    public void testDateParseInvalidMonth() {
+  @Test
+  public void testDateParseInvalidMonth() {
       String dateStr = "2022-14-30";
       try {
         ISO8601Utils.parse(dateStr, new ParsePosition(0));
@@ -86,8 +86,8 @@ public class ISO8601UtilsTest {
       }
     }
 
-    @Test
-    public void testDateParseWithTimezone() throws ParseException {
+  @Test
+  public void testDateParseWithTimezone() throws ParseException {
         String dateStr = "2018-06-25T00:00:00-03:00";
         Date date = ISO8601Utils.parse(dateStr, new ParsePosition(0));
         GregorianCalendar calendar = createUtcCalendar();
@@ -96,8 +96,8 @@ public class ISO8601UtilsTest {
         assertEquals(expectedDate, date);
     }
 
-    @Test
-    public void testDateParseSpecialTimezone() throws ParseException {
+  @Test
+  public void testDateParseSpecialTimezone() throws ParseException {
         String dateStr = "2018-06-25T00:02:00-02:58";
         Date date = ISO8601Utils.parse(dateStr, new ParsePosition(0));
         GregorianCalendar calendar = createUtcCalendar();
@@ -106,8 +106,8 @@ public class ISO8601UtilsTest {
         assertEquals(expectedDate, date);
     }
 
-    @Test
-    public void testDateParseInvalidTime() throws ParseException {
+  @Test
+  public void testDateParseInvalidTime() throws ParseException {
         final String dateStr = "2018-06-25T61:60:62-03:00";
         assertThrows(ParseException.class, new ThrowingRunnable() {
           @Override
diff --git a/gson/src/test/java/com/google/gson/internal/sql/SqlTypesGsonTest.java b/gson/src/test/java/com/google/gson/internal/sql/SqlTypesGsonTest.java
index 5553fdd0..8668d138 100644
--- a/gson/src/test/java/com/google/gson/internal/sql/SqlTypesGsonTest.java
+++ b/gson/src/test/java/com/google/gson/internal/sql/SqlTypesGsonTest.java
@@ -1,26 +1,27 @@
 package com.google.gson.internal.sql;
 
-import java.sql.Date;
-import java.sql.Time;
-import java.sql.Timestamp;
-import java.util.Locale;
-import java.util.TimeZone;
+import static org.junit.Assert.assertEquals;
 
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
 import com.google.gson.functional.DefaultTypeAdaptersTest;
 import com.google.gson.internal.JavaVersion;
+import java.sql.Date;
+import java.sql.Time;
+import java.sql.Timestamp;
+import java.util.Locale;
+import java.util.TimeZone;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
 
-import junit.framework.TestCase;
-
-public class SqlTypesGsonTest extends TestCase {
+public class SqlTypesGsonTest {
   private Gson gson;
   private TimeZone oldTimeZone;
   private Locale oldLocale;
 
-  @Override
-  protected void setUp() throws Exception {
-    super.setUp();
+  @Before
+  public void setUp() throws Exception {
     this.oldTimeZone = TimeZone.getDefault();
     TimeZone.setDefault(TimeZone.getTimeZone("America/Los_Angeles"));
     this.oldLocale = Locale.getDefault();
@@ -28,13 +29,13 @@ public class SqlTypesGsonTest extends TestCase {
     gson = new Gson();
   }
 
-  @Override
-  protected void tearDown() throws Exception {
-    super.tearDown();
+  @After
+  public void tearDown() throws Exception {
     TimeZone.setDefault(oldTimeZone);
     Locale.setDefault(oldLocale);
   }
 
+  @Test
   public void testNullSerializationAndDeserialization() {
     testNullSerializationAndDeserialization(Date.class);
     testNullSerializationAndDeserialization(Time.class);
@@ -45,12 +46,14 @@ public class SqlTypesGsonTest extends TestCase {
     DefaultTypeAdaptersTest.testNullSerializationAndDeserialization(gson, c);
   }
 
+  @Test
   public void testDefaultSqlDateSerialization() {
     java.sql.Date instant = new java.sql.Date(1259875082000L);
     String json = gson.toJson(instant);
     assertEquals("\"Dec 3, 2009\"", json);
   }
 
+  @Test
   public void testDefaultSqlDateDeserialization() {
     String json = "\"Dec 3, 2009\"";
     java.sql.Date extracted = gson.fromJson(json, java.sql.Date.class);
@@ -58,6 +61,7 @@ public class SqlTypesGsonTest extends TestCase {
   }
 
   // http://code.google.com/p/google-gson/issues/detail?id=230
+  @Test
   public void testSqlDateSerialization() throws Exception {
     TimeZone defaultTimeZone = TimeZone.getDefault();
     TimeZone.setDefault(TimeZone.getTimeZone("UTC"));
@@ -75,18 +79,21 @@ public class SqlTypesGsonTest extends TestCase {
     }
   }
 
+  @Test
   public void testDefaultSqlTimeSerialization() {
     Time now = new Time(1259875082000L);
     String json = gson.toJson(now);
     assertEquals("\"01:18:02 PM\"", json);
   }
 
+  @Test
   public void testDefaultSqlTimeDeserialization() {
     String json = "\"1:18:02 PM\"";
     Time extracted = gson.fromJson(json, Time.class);
     DefaultTypeAdaptersTest.assertEqualsTime(extracted, 13, 18, 2);
   }
 
+  @Test
   public void testDefaultSqlTimestampSerialization() {
     Timestamp now = new java.sql.Timestamp(1259875082000L);
     String json = gson.toJson(now);
@@ -97,6 +104,7 @@ public class SqlTypesGsonTest extends TestCase {
     }
   }
 
+  @Test
   public void testDefaultSqlTimestampDeserialization() {
     String json = "\"Dec 3, 2009 1:18:02 PM\"";
     Timestamp extracted = gson.fromJson(json, Timestamp.class);
@@ -105,6 +113,7 @@ public class SqlTypesGsonTest extends TestCase {
   }
 
   // http://code.google.com/p/google-gson/issues/detail?id=230
+  @Test
   public void testTimestampSerialization() throws Exception {
     TimeZone defaultTimeZone = TimeZone.getDefault();
     TimeZone.setDefault(TimeZone.getTimeZone("UTC"));
diff --git a/gson/src/test/java/com/google/gson/internal/sql/SqlTypesSupportTest.java b/gson/src/test/java/com/google/gson/internal/sql/SqlTypesSupportTest.java
index ea496f4a..51244283 100644
--- a/gson/src/test/java/com/google/gson/internal/sql/SqlTypesSupportTest.java
+++ b/gson/src/test/java/com/google/gson/internal/sql/SqlTypesSupportTest.java
@@ -1,8 +1,12 @@
 package com.google.gson.internal.sql;
 
-import junit.framework.TestCase;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
 
-public class SqlTypesSupportTest extends TestCase {
+import org.junit.Test;
+
+public class SqlTypesSupportTest {
+  @Test
   public void testSupported() {
     assertTrue(SqlTypesSupport.SUPPORTS_SQL_TYPES);
 
diff --git a/gson/src/test/java/com/google/gson/jf/Box.java b/gson/src/test/java/com/google/gson/jf/Box.java
new file mode 100644
index 00000000..9c8396fa
--- /dev/null
+++ b/gson/src/test/java/com/google/gson/jf/Box.java
@@ -0,0 +1,23 @@
+package com.google.gson.jf;
+
+import java.util.List;
+
+public class Box {
+  public static class StringArray {
+    public String[] collection;
+  }
+
+  public static class StringList {
+    public List<String> collection;
+
+    public static StringList of(String... list) {
+      StringList sl = new StringList();
+      sl.collection = List.of(list);
+      return sl;
+    }
+  }
+
+  public static class IntList {
+    public List<Integer> collection;
+  }
+}
diff --git a/gson/src/test/java/com/google/gson/jf/CommentsTest.java b/gson/src/test/java/com/google/gson/jf/CommentsTest.java
index 1e072263..6b015fe4 100644
--- a/gson/src/test/java/com/google/gson/jf/CommentsTest.java
+++ b/gson/src/test/java/com/google/gson/jf/CommentsTest.java
@@ -16,25 +16,27 @@
 
 package com.google.gson.jf;
 
-import com.google.gson.*;
-import com.google.gson.common.*;
+import com.google.gson.GsonBuilder;
 import com.google.gson.reflect.TypeToken;
+import com.google.gson.stream.JsonWriter;
+import org.junit.Test;
 
-import java.io.*;
+import java.io.IOException;
+import java.io.StringWriter;
 import java.util.Arrays;
 import java.util.List;
 
-import com.google.gson.stream.*;
-import junit.framework.TestCase;
+import static com.google.common.truth.Truth.assertThat;
 
 /**
  * @author Jesse Wilson
  */
-public final class CommentsTest extends TestCase {
+public final class CommentsTest {
 
   /**
    * Test for issue 212.
    */
+  @Test
   public void testParseComments() {
     String json = "[\n"
         + "  // this is a comment\n"
@@ -46,9 +48,10 @@ public final class CommentsTest extends TestCase {
         + "]";
 
     List<String> abc = new GsonBuilder().setLenient().create().fromJson(json, new TypeToken<List<String>>() {}.getType());
-    assertEquals(Arrays.asList("a", "b", "c"), abc);
+    assertThat(abc).isEqualTo(Arrays.asList("a", "b", "c"));
   }
 
+  @Test
   public void testWriteComments() throws IOException {
     String expectedJson = "// comment at file head\n"
         + "[\n"
@@ -86,7 +89,7 @@ public final class CommentsTest extends TestCase {
       .comment("comment behind the object");
 
     jw.close();
-    assertEquals(expectedJson, sw.toString());
+    assertThat(sw.toString()).isEqualTo(expectedJson);
     sw.close();
   }
 }
diff --git a/gson/src/test/java/com/google/gson/jf/ExtraAssert.java b/gson/src/test/java/com/google/gson/jf/ExtraAssert.java
deleted file mode 100644
index 320f80f3..00000000
--- a/gson/src/test/java/com/google/gson/jf/ExtraAssert.java
+++ /dev/null
@@ -1,28 +0,0 @@
-package com.google.gson.jf;
-
-import junit.framework.*;
-
-import java.util.*;
-
-public class ExtraAssert {
-  public static <T> void assertListEquals(List<T> expecteds, List<T> actuals) {
-    TestCase.assertNotNull(expecteds);
-    TestCase.assertNotNull(actuals);
-    TestCase.assertEquals(expecteds.size(), actuals.size());
-    for (int i = 0; i < expecteds.size(); i++) {
-      TestCase.assertEquals(expecteds.get(i), actuals.get(i));
-    }
-  }
-
-  public static class StringArrayBox {
-    public String[] collection;
-  }
-
-  public static class StringListBox {
-    public List<String> collection;
-  }
-
-  public static class IntListBox {
-    public List<Integer> collection;
-  }
-}
diff --git a/gson/src/test/java/com/google/gson/jf/Json5Test.java b/gson/src/test/java/com/google/gson/jf/Json5Test.java
index 32d58a20..277360c1 100644
--- a/gson/src/test/java/com/google/gson/jf/Json5Test.java
+++ b/gson/src/test/java/com/google/gson/jf/Json5Test.java
@@ -1,12 +1,15 @@
 package com.google.gson.jf;
 
-import com.google.gson.*;
-import junit.framework.*;
+import com.google.gson.Gson;
+import org.junit.Test;
 
-public class Json5Test extends TestCase {
+import static com.google.common.truth.Truth.assertThat;
+
+public class Json5Test {
+    @Test
     public void testShortExample() {
         // Taken from the official example
-        assertTrue(new Gson().fromJson("{\n" +
+        assertThat(new Gson().fromJson("{\n" +
                 "  // comments\n" +
                 "  unquoted: 'and you can quote me on that',\n" +
                 "  singleQuotes: 'I can use \"double quotes\" here',\n" +
@@ -17,7 +20,8 @@ public class Json5Test extends TestCase {
                 "  positiveSign: +1,\n" +
                 "  trailingComma: 'in objects', andIn: ['arrays',],\n" +
                 "  \"backwardsCompatible\": \"with JSON\"\n" + // The original includes a trailing comma here, that is not yet supported
-                "}", ExampleModel.class).isDefault());
+                "}", ExampleModel.class).isDefault())
+                .isTrue();
     }
 
     public static class ExampleModel {
diff --git a/gson/src/test/java/com/google/gson/jf/LenientCollectionCommaTest.java b/gson/src/test/java/com/google/gson/jf/LenientCollectionCommaTest.java
index b8515e4b..33c93e46 100644
--- a/gson/src/test/java/com/google/gson/jf/LenientCollectionCommaTest.java
+++ b/gson/src/test/java/com/google/gson/jf/LenientCollectionCommaTest.java
@@ -1,22 +1,20 @@
 package com.google.gson.jf;
 
-import com.google.gson.*;
-import junit.framework.TestCase;
-import java.util.*;
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import org.junit.Test;
 
-import static com.google.gson.jf.ExtraAssert.*;
+import java.util.List;
 
-public class LenientCollectionCommaTest extends TestCase {
-  private Gson lenient;
+import static com.google.common.truth.Truth.assertThat;
+
+public class LenientCollectionCommaTest {
+  private Gson lenient = new GsonBuilder().setLenient().create();
   private static final String json = "{\"collection\": [1, 2,, 3, , , 4, 5,]}";
 
-  @Override
-  protected void setUp() throws Exception {
-    super.setUp();
-    lenient = new GsonBuilder().setLenient().create();
-  }
-
+  @Test
   public void testElementSkipping() {
-    assertListEquals(List.of(1, 2, 3, 4, 5), lenient.fromJson(json, IntListBox.class).collection);
+    assertThat(lenient.fromJson(json, Box.IntList.class).collection)
+            .isEqualTo(List.of(1, 2, 3, 4, 5));
   }
 }
diff --git a/gson/src/test/java/com/google/gson/jf/LenientCollectionTest.java b/gson/src/test/java/com/google/gson/jf/LenientCollectionTest.java
index c3730bf6..fc067701 100644
--- a/gson/src/test/java/com/google/gson/jf/LenientCollectionTest.java
+++ b/gson/src/test/java/com/google/gson/jf/LenientCollectionTest.java
@@ -1,45 +1,43 @@
 package com.google.gson.jf;
 
-import com.google.gson.*;
-import junit.framework.TestCase;
-import java.util.*;
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.JsonParseException;
+import org.junit.Test;
 
-import static org.junit.Assert.*;
-import static com.google.gson.jf.ExtraAssert.*;
+import java.util.List;
 
-public class LenientCollectionTest extends TestCase {
-  private Gson lenient;
-  private Gson strict;
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertThrows;
+
+public class LenientCollectionTest {
+  private Gson lenient = new GsonBuilder().setLenient().create();
+  private Gson strict = new GsonBuilder().create();
   private static final String json = "{\"collection\": \"example\"}";
 
-  @Override
-  protected void setUp() throws Exception {
-    super.setUp();
-    lenient = new GsonBuilder().setLenient().create();
-    strict = new GsonBuilder().create();
-  }
-
+  @Test
   public void testLenientArray() {
-    assertArrayEquals(new String[] {"example"}, lenient.fromJson(json, StringArrayBox.class).collection);
+    assertThat(lenient.fromJson(json, Box.StringArray.class).collection)
+            .isEqualTo(new String[] {"example"});
   }
 
+  @Test
   public void testLenientList() {
-    assertListEquals(List.of("example"), lenient.fromJson(json, StringListBox.class).collection);
+    assertThat(lenient.fromJson(json, Box.StringList.class).collection)
+            .isEqualTo(List.of("example"));
   }
 
+  @Test
   public void testStrictArray() {
-    try {
-      strict.fromJson(json, StringArrayBox.class);
-      fail("Strict Gson should not deserialize array without brackets");
-    } catch (JsonParseException expected) {
-    }
+    assertThrows("Strict Gson should not deserialize array without brackets",
+            JsonParseException.class,
+            () -> strict.fromJson(json, Box.StringArray.class));
   }
 
+  @Test
   public void testStrictList() {
-    try {
-      strict.fromJson(json, StringListBox.class);
-      fail("Strict Gson should not deserialize list without brackets");
-    } catch (JsonParseException expected) {
-    }
+    assertThrows("Strict Gson should not deserialize list without brackets",
+            JsonParseException.class,
+            () -> strict.fromJson(json, Box.StringList.class));
   }
 }
diff --git a/gson/src/test/java/com/google/gson/jf/OmitQuotesTest.java b/gson/src/test/java/com/google/gson/jf/OmitQuotesTest.java
index bcba20df..5914072f 100644
--- a/gson/src/test/java/com/google/gson/jf/OmitQuotesTest.java
+++ b/gson/src/test/java/com/google/gson/jf/OmitQuotesTest.java
@@ -1,33 +1,25 @@
 package com.google.gson.jf;
 
-import com.google.gson.*;
-import junit.framework.*;
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import org.junit.Test;
 
-import java.util.*;
+import static com.google.common.truth.Truth.assertThat;
 
-import static com.google.gson.jf.ExtraAssert.*;
-
-public class OmitQuotesTest extends TestCase {
-    private Gson lenient;
-    private Gson strict;
+public class OmitQuotesTest {
+    private Gson lenient = new GsonBuilder().setOmitQuotes().create();
+    private Gson strict = new GsonBuilder().create();
     private static final String lenientJson = "{collection:[\"example\"]}";
     private static final String strictJson = "{\"collection\":[\"example\"]}";
-    private StringListBox slb;
-
-    @Override
-    protected void setUp() throws Exception {
-        super.setUp();
-        lenient = new GsonBuilder().setOmitQuotes().create();
-        strict = new GsonBuilder().create();
-        slb = new StringListBox();
-        slb.collection = List.of("example");
-    }
+    private Box.StringList slb = Box.StringList.of("example");
 
+    @Test
     public void testLenient() {
-        assertEquals(lenientJson, lenient.toJson(slb));
+        assertThat(lenient.toJson(slb)).isEqualTo(lenientJson);
     }
 
+    @Test
     public void testStrict() {
-        assertEquals(strictJson, strict.toJson(slb));
+        assertThat(strict.toJson(slb)).isEqualTo(strictJson);
     }
 }
diff --git a/gson/src/test/java/com/google/gson/jf/ReadNullTest.java b/gson/src/test/java/com/google/gson/jf/ReadNullTest.java
index 6a7da38c..575dfa52 100644
--- a/gson/src/test/java/com/google/gson/jf/ReadNullTest.java
+++ b/gson/src/test/java/com/google/gson/jf/ReadNullTest.java
@@ -3,22 +3,27 @@ package com.google.gson.jf;
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
 import com.google.gson.stream.JsonReader;
-import junit.framework.TestCase;
+import org.junit.Test;
 
-import java.io.*;
+import java.io.IOException;
+import java.io.Reader;
+import java.io.StringReader;
 
-public class ReadNullTest extends TestCase {
+import static com.google.common.truth.Truth.assertThat;
+
+public class ReadNullTest {
+    @Test
     public void testReadNull() throws IOException {
         Gson gson = new GsonBuilder().serializeNulls().setLenient().create();
         String exampleFile = "{\n  // Yes\n  \"value1\": 1024,\n  \"value2\": null,\n  \"value3\": 10\n}";
         try (Reader r = new StringReader(exampleFile); JsonReader jr = gson.newJsonReader(r)) {
             jr.beginObject();
-            assertEquals("value1", jr.nextName());
-            assertEquals(1024, jr.nextInt());
-            assertEquals("value2", jr.nextName());
+            assertThat(jr.nextName()).isEqualTo("value1");
+            assertThat(jr.nextInt()).isEqualTo(1024);
+            assertThat(jr.nextName()).isEqualTo("value2");
             jr.nextNull();
-            assertEquals("value3", jr.nextName());
-            assertEquals(10, jr.nextInt());
+            assertThat(jr.nextName()).isEqualTo("value3");
+            assertThat(jr.nextInt()).isEqualTo(10);
             jr.endObject();
         }
     }
diff --git a/gson/src/test/java/com/google/gson/metrics/PerformanceTest.java b/gson/src/test/java/com/google/gson/metrics/PerformanceTest.java
index e0ff0653..5670506b 100644
--- a/gson/src/test/java/com/google/gson/metrics/PerformanceTest.java
+++ b/gson/src/test/java/com/google/gson/metrics/PerformanceTest.java
@@ -16,19 +16,22 @@
 
 package com.google.gson.metrics;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
 import com.google.gson.Gson;
 import com.google.gson.JsonParseException;
 import com.google.gson.annotations.Expose;
 import com.google.gson.reflect.TypeToken;
-
-import junit.framework.TestCase;
-
 import java.io.StringWriter;
 import java.lang.reflect.Type;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Test;
 
 /**
  * Tests to measure performance for Gson. All tests in this file will be disabled in code. To run
@@ -37,23 +40,25 @@ import java.util.Map;
  * @author Inderjeet Singh
  * @author Joel Leitch
  */
-public class PerformanceTest extends TestCase {
+public class PerformanceTest {
   private static final int COLLECTION_SIZE = 5000;
 
   private static final int NUM_ITERATIONS = 100;
 
   private Gson gson;
 
-  @Override
-  protected void setUp() throws Exception {
-    super.setUp();
+  @Before
+  public void setUp() throws Exception {
     gson = new Gson();
   }
   
+  @Test
   public void testDummy() {
     // This is here to prevent Junit for complaining when we disable all tests.
   }
 
+  @Test
+  @Ignore
   public void disabled_testStringDeserialization() {
     StringBuilder sb = new StringBuilder(8096);
     sb.append("Error Yippie");
@@ -111,6 +116,8 @@ public class PerformanceTest extends TestCase {
   /**
    * Created in response to http://code.google.com/p/google-gson/issues/detail?id=96
    */
+  @Test
+  @Ignore
   public void disabled_testLargeCollectionSerialization() {
     int count = 1400000;
     List<CollectionEntry> list = new ArrayList<>(count);
@@ -123,6 +130,8 @@ public class PerformanceTest extends TestCase {
   /**
    * Created in response to http://code.google.com/p/google-gson/issues/detail?id=96
    */
+  @Test
+  @Ignore
   public void disabled_testLargeCollectionDeserialization() {
     StringBuilder sb = new StringBuilder();
     int count = 87000;
@@ -147,6 +156,8 @@ public class PerformanceTest extends TestCase {
    * Created in response to http://code.google.com/p/google-gson/issues/detail?id=96
    */
   // Last I tested, Gson was able to serialize upto 14MB byte array
+  @Test
+  @Ignore
   public void disabled_testByteArraySerialization() {
     for (int size = 4145152; true; size += 1036288) {
       byte[] ba = new byte[size];
@@ -162,6 +173,8 @@ public class PerformanceTest extends TestCase {
    * Created in response to http://code.google.com/p/google-gson/issues/detail?id=96
    */
   // Last I tested, Gson was able to deserialize a byte array of 11MB
+  @Test
+  @Ignore
   public void disabled_testByteArrayDeserialization() {
     for (int numElements = 10639296; true; numElements += 16384) {
       StringBuilder sb = new StringBuilder(numElements*2);
@@ -190,7 +203,9 @@ public class PerformanceTest extends TestCase {
 // Deserialized classes avg time: 70 ms
 // Serialize exposed classes avg time: 159 ms
 // Deserialized exposed classes avg time: 173 ms
-  
+
+  @Test
+  @Ignore
   public void disabled_testSerializeClasses() {
     ClassWithList c = new ClassWithList("str"); 
     for (int i = 0; i < COLLECTION_SIZE; ++i) { 
@@ -206,6 +221,8 @@ public class PerformanceTest extends TestCase {
     System.out.printf("Serialize classes avg time: %d ms\n", avg);
   }
 
+  @Test
+  @Ignore
   public void disabled_testDeserializeClasses() {
     String json = buildJsonForClassWithList();
     ClassWithList[] target = new ClassWithList[NUM_ITERATIONS];
@@ -217,7 +234,9 @@ public class PerformanceTest extends TestCase {
     long avg = (t2 - t1) / NUM_ITERATIONS;
     System.out.printf("Deserialize classes avg time: %d ms\n", avg);
   }
-  
+
+  @Test
+  @Ignore
   public void disabled_testLargeObjectSerializationAndDeserialization() {
     Map<String, Long> largeObject = new HashMap<>();
     for (long l = 0; l < 100000; l++) {
@@ -236,6 +255,8 @@ public class PerformanceTest extends TestCase {
     
   }
 
+  @Test
+  @Ignore
   public void disabled_testSerializeExposedClasses() {
     ClassWithListOfObjects c1 = new ClassWithListOfObjects("str"); 
     for (int i1 = 0; i1 < COLLECTION_SIZE; ++i1) { 
@@ -252,6 +273,8 @@ public class PerformanceTest extends TestCase {
     System.out.printf("Serialize exposed classes avg time: %d ms\n", avg);
   }
 
+  @Test
+  @Ignore
   public void disabled_testDeserializeExposedClasses() {
     String json = buildJsonForClassWithList();
     ClassWithListOfObjects[] target = new ClassWithListOfObjects[NUM_ITERATIONS];
@@ -264,6 +287,8 @@ public class PerformanceTest extends TestCase {
     System.out.printf("Deserialize exposed classes avg time: %d ms\n", avg);
   }
 
+  @Test
+  @Ignore
   public void disabled_testLargeGsonMapRoundTrip() throws Exception {
     Map<Long, Long> original = new HashMap<>();
     for (long i = 0; i < 1000000; i++) {
diff --git a/gson/src/test/java/com/google/gson/reflect/TypeTokenTest.java b/gson/src/test/java/com/google/gson/reflect/TypeTokenTest.java
index 55c2e823..89c5c4c3 100644
--- a/gson/src/test/java/com/google/gson/reflect/TypeTokenTest.java
+++ b/gson/src/test/java/com/google/gson/reflect/TypeTokenTest.java
@@ -16,6 +16,11 @@
 
 package com.google.gson.reflect;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
 import java.lang.reflect.GenericArrayType;
 import java.lang.reflect.Type;
 import java.util.ArrayList;
@@ -23,12 +28,12 @@ import java.util.List;
 import java.util.Map;
 import java.util.RandomAccess;
 import java.util.Set;
-import junit.framework.TestCase;
+import org.junit.Test;
 
 /**
  * @author Jesse Wilson
  */
-public final class TypeTokenTest extends TestCase {
+public final class TypeTokenTest {
   // These fields are accessed using reflection by the tests below
   List<Integer> listOfInteger = null;
   List<Number> listOfNumber = null;
@@ -38,6 +43,7 @@ public final class TypeTokenTest extends TestCase {
   List<Set<?>> listOfSetOfUnknown = null;
 
   @SuppressWarnings({"deprecation"})
+  @Test
   public void testIsAssignableFromRawTypes() {
     assertTrue(TypeToken.get(Object.class).isAssignableFrom(String.class));
     assertFalse(TypeToken.get(String.class).isAssignableFrom(Object.class));
@@ -46,6 +52,7 @@ public final class TypeTokenTest extends TestCase {
   }
 
   @SuppressWarnings({"deprecation"})
+  @Test
   public void testIsAssignableFromWithTypeParameters() throws Exception {
     Type a = getClass().getDeclaredField("listOfInteger").getGenericType();
     Type b = getClass().getDeclaredField("listOfNumber").getGenericType();
@@ -59,6 +66,7 @@ public final class TypeTokenTest extends TestCase {
   }
 
   @SuppressWarnings({"deprecation"})
+  @Test
   public void testIsAssignableFromWithBasicWildcards() throws Exception {
     Type a = getClass().getDeclaredField("listOfString").getGenericType();
     Type b = getClass().getDeclaredField("listOfUnknown").getGenericType();
@@ -73,6 +81,7 @@ public final class TypeTokenTest extends TestCase {
   }
 
   @SuppressWarnings({"deprecation"})
+  @Test
   public void testIsAssignableFromWithNestedWildcards() throws Exception {
     Type a = getClass().getDeclaredField("listOfSetOfString").getGenericType();
     Type b = getClass().getDeclaredField("listOfSetOfUnknown").getGenericType();
@@ -85,6 +94,7 @@ public final class TypeTokenTest extends TestCase {
     assertFalse(TypeToken.get(b).isAssignableFrom(a));
   }
 
+  @Test
   public void testArrayFactory() {
     TypeToken<?> expectedStringArray = new TypeToken<String[]>() {};
     assertEquals(expectedStringArray, TypeToken.getArray(String.class));
@@ -100,6 +110,7 @@ public final class TypeTokenTest extends TestCase {
     }
   }
 
+  @Test
   public void testParameterizedFactory() {
     TypeToken<?> expectedListOfString = new TypeToken<List<String>>() {};
     assertEquals(expectedListOfString, TypeToken.getParameterized(List.class, String.class));
@@ -122,6 +133,7 @@ public final class TypeTokenTest extends TestCase {
     assertEquals(expectedSatisfyingTwoBounds, TypeToken.getParameterized(GenericWithMultiBound.class, ClassSatisfyingBounds.class));
   }
 
+  @Test
   public void testParameterizedFactory_Invalid() {
     try {
       TypeToken.getParameterized(null, new Type[0]);
@@ -207,6 +219,7 @@ public final class TypeTokenTest extends TestCase {
   private static class CustomTypeToken extends TypeToken<String> {
   }
 
+  @Test
   public void testTypeTokenNonAnonymousSubclass() {
     TypeToken<?> typeToken = new CustomTypeToken();
     assertEquals(String.class, typeToken.getRawType());
@@ -217,6 +230,7 @@ public final class TypeTokenTest extends TestCase {
    * User must only create direct subclasses of TypeToken, but not subclasses
    * of subclasses (...) of TypeToken.
    */
+  @Test
   public void testTypeTokenSubSubClass() {
     class SubTypeToken<T> extends TypeToken<String> {}
     class SubSubTypeToken1<T> extends SubTypeToken<T> {}
@@ -245,6 +259,7 @@ public final class TypeTokenTest extends TestCase {
   }
 
   @SuppressWarnings("rawtypes")
+  @Test
   public void testTypeTokenRaw() {
     try {
       new TypeToken() {};
diff --git a/gson/src/test/java/com/google/gson/regression/JsonAdapterNullSafeTest.java b/gson/src/test/java/com/google/gson/regression/JsonAdapterNullSafeTest.java
index 0c63fe8d..a9ae2877 100644
--- a/gson/src/test/java/com/google/gson/regression/JsonAdapterNullSafeTest.java
+++ b/gson/src/test/java/com/google/gson/regression/JsonAdapterNullSafeTest.java
@@ -15,22 +15,25 @@
  */
 package com.google.gson.regression;
 
+import static org.junit.Assert.assertEquals;
+
 import com.google.gson.Gson;
 import com.google.gson.TypeAdapter;
 import com.google.gson.TypeAdapterFactory;
 import com.google.gson.annotations.JsonAdapter;
 import com.google.gson.reflect.TypeToken;
+import org.junit.Test;
 
-import junit.framework.TestCase;
-
-public class JsonAdapterNullSafeTest extends TestCase {
+public class JsonAdapterNullSafeTest {
   private final Gson gson = new Gson();
 
+  @Test
   public void testNullSafeBugSerialize() throws Exception {
     Device device = new Device("ec57803e");
     gson.toJson(device);
   }
 
+  @Test
   public void testNullSafeBugDeserialize() throws Exception {
     Device device = gson.fromJson("{\"id\":\"ec57803e2\"}", Device.class);
     assertEquals("ec57803e2", device.id);
diff --git a/gson/src/test/java/com/google/gson/regression/OSGiTest.java b/gson/src/test/java/com/google/gson/regression/OSGiTest.java
index c41b12f4..9512241c 100644
--- a/gson/src/test/java/com/google/gson/regression/OSGiTest.java
+++ b/gson/src/test/java/com/google/gson/regression/OSGiTest.java
@@ -15,25 +15,29 @@
  */
 package com.google.gson.regression;
 
-import java.io.InputStream;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.fail;
+
 import java.io.IOException;
+import java.io.InputStream;
 import java.net.URL;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 import java.util.jar.Manifest;
+import org.junit.Test;
 
-import junit.framework.TestCase;
-
-public class OSGiTest extends TestCase {
-    public void testComGoogleGsonAnnotationsPackage() throws Exception {
+public class OSGiTest {
+  @Test
+  public void testComGoogleGsonAnnotationsPackage() throws Exception {
         Manifest mf = findManifest("com.google.gson");
         String importPkg = mf.getMainAttributes().getValue("Import-Package");
         assertNotNull("Import-Package statement is there", importPkg);
         assertSubstring("There should be com.google.gson.annotations dependency", importPkg, "com.google.gson.annotations");
     }
 
-    public void testSunMiscImportPackage() throws Exception {
+  @Test
+  public void testSunMiscImportPackage() throws Exception {
         Manifest mf = findManifest("com.google.gson");
         String importPkg = mf.getMainAttributes().getValue("Import-Package");
         assertNotNull("Import-Package statement is there", importPkg);
diff --git a/gson/src/test/java/com/google/gson/stream/JsonReaderTest.java b/gson/src/test/java/com/google/gson/stream/JsonReaderTest.java
index 8aa0bd01..9431b5e1 100644
--- a/gson/src/test/java/com/google/gson/stream/JsonReaderTest.java
+++ b/gson/src/test/java/com/google/gson/stream/JsonReaderTest.java
@@ -25,17 +25,23 @@ import static com.google.gson.stream.JsonToken.NAME;
 import static com.google.gson.stream.JsonToken.NULL;
 import static com.google.gson.stream.JsonToken.NUMBER;
 import static com.google.gson.stream.JsonToken.STRING;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
 
 import java.io.EOFException;
 import java.io.IOException;
 import java.io.Reader;
 import java.io.StringReader;
 import java.util.Arrays;
-import junit.framework.TestCase;
+import org.junit.Ignore;
+import org.junit.Test;
 
 @SuppressWarnings("resource")
-public final class JsonReaderTest extends TestCase {
+public final class JsonReaderTest {
+  @Test
   public void testReadArray() throws IOException {
     JsonReader reader = new JsonReader(reader("[true, true]"));
     reader.beginArray();
@@ -45,6 +51,7 @@ public final class JsonReaderTest extends TestCase {
     assertEquals(JsonToken.END_DOCUMENT, reader.peek());
   }
 
+  @Test
   public void testReadEmptyArray() throws IOException {
     JsonReader reader = new JsonReader(reader("[]"));
     reader.beginArray();
@@ -53,6 +60,7 @@ public final class JsonReaderTest extends TestCase {
     assertEquals(JsonToken.END_DOCUMENT, reader.peek());
   }
 
+  @Test
   public void testReadObject() throws IOException {
     JsonReader reader = new JsonReader(reader(
         "{\"a\": \"android\", \"b\": \"banana\"}"));
@@ -65,6 +73,7 @@ public final class JsonReaderTest extends TestCase {
     assertEquals(JsonToken.END_DOCUMENT, reader.peek());
   }
 
+  @Test
   public void testReadEmptyObject() throws IOException {
     JsonReader reader = new JsonReader(reader("{}"));
     reader.beginObject();
@@ -73,6 +82,7 @@ public final class JsonReaderTest extends TestCase {
     assertEquals(JsonToken.END_DOCUMENT, reader.peek());
   }
 
+  @Test
   public void testHasNextEndOfDocument() throws IOException {
     JsonReader reader = new JsonReader(reader("{}"));
     reader.beginObject();
@@ -80,6 +90,7 @@ public final class JsonReaderTest extends TestCase {
     assertFalse(reader.hasNext());
   }
 
+  @Test
   public void testSkipArray() throws IOException {
     JsonReader reader = new JsonReader(reader(
         "{\"a\": [\"one\", \"two\", \"three\"], \"b\": 123}"));
@@ -92,6 +103,7 @@ public final class JsonReaderTest extends TestCase {
     assertEquals(JsonToken.END_DOCUMENT, reader.peek());
   }
 
+  @Test
   public void testSkipArrayAfterPeek() throws Exception {
     JsonReader reader = new JsonReader(reader(
         "{\"a\": [\"one\", \"two\", \"three\"], \"b\": 123}"));
@@ -105,6 +117,7 @@ public final class JsonReaderTest extends TestCase {
     assertEquals(JsonToken.END_DOCUMENT, reader.peek());
   }
 
+  @Test
   public void testSkipTopLevelObject() throws Exception {
     JsonReader reader = new JsonReader(reader(
         "{\"a\": [\"one\", \"two\", \"three\"], \"b\": 123}"));
@@ -112,6 +125,7 @@ public final class JsonReaderTest extends TestCase {
     assertEquals(JsonToken.END_DOCUMENT, reader.peek());
   }
 
+  @Test
   public void testSkipObject() throws IOException {
     JsonReader reader = new JsonReader(reader(
         "{\"a\": { \"c\": [], \"d\": [true, true, {}] }, \"b\": \"banana\"}"));
@@ -124,6 +138,7 @@ public final class JsonReaderTest extends TestCase {
     assertEquals(JsonToken.END_DOCUMENT, reader.peek());
   }
 
+  @Test
   public void testSkipObjectAfterPeek() throws Exception {
     String json = "{" + "  \"one\": { \"num\": 1 }"
         + ", \"two\": { \"num\": 2 }" + ", \"three\": { \"num\": 3 }" + "}";
@@ -141,6 +156,7 @@ public final class JsonReaderTest extends TestCase {
     assertEquals(JsonToken.END_DOCUMENT, reader.peek());
   }
 
+  @Test
   public void testSkipObjectName() throws IOException {
     JsonReader reader = new JsonReader(reader("{\"a\": 1}"));
     reader.beginObject();
@@ -150,6 +166,7 @@ public final class JsonReaderTest extends TestCase {
     assertEquals(1, reader.nextInt());
   }
 
+  @Test
   public void testSkipObjectNameSingleQuoted() throws IOException {
     JsonReader reader = new JsonReader(reader("{'a': 1}"));
     reader.setLenient(true);
@@ -160,6 +177,7 @@ public final class JsonReaderTest extends TestCase {
     assertEquals(1, reader.nextInt());
   }
 
+  @Test
   public void testSkipObjectNameUnquoted() throws IOException {
     JsonReader reader = new JsonReader(reader("{a: 1}"));
     reader.setLenient(true);
@@ -170,6 +188,7 @@ public final class JsonReaderTest extends TestCase {
     assertEquals(1, reader.nextInt());
   }
 
+  @Test
   public void testSkipInteger() throws IOException {
     JsonReader reader = new JsonReader(reader(
         "{\"a\":123456789,\"b\":-123456789}"));
@@ -182,6 +201,7 @@ public final class JsonReaderTest extends TestCase {
     assertEquals(JsonToken.END_DOCUMENT, reader.peek());
   }
 
+  @Test
   public void testSkipDouble() throws IOException {
     JsonReader reader = new JsonReader(reader(
         "{\"a\":-123.456e-789,\"b\":123456789.0}"));
@@ -194,6 +214,7 @@ public final class JsonReaderTest extends TestCase {
     assertEquals(JsonToken.END_DOCUMENT, reader.peek());
   }
 
+  @Test
   public void testSkipValueAfterEndOfDocument() throws IOException {
     JsonReader reader = new JsonReader(reader("{}"));
     reader.beginObject();
@@ -206,6 +227,7 @@ public final class JsonReaderTest extends TestCase {
     assertEquals("$", reader.getPath());
   }
 
+  @Test
   public void testSkipValueAtArrayEnd() throws IOException {
     JsonReader reader = new JsonReader(reader("[]"));
     reader.beginArray();
@@ -214,6 +236,7 @@ public final class JsonReaderTest extends TestCase {
     assertEquals("$", reader.getPath());
   }
 
+  @Test
   public void testSkipValueAtObjectEnd() throws IOException {
     JsonReader reader = new JsonReader(reader("{}"));
     reader.beginObject();
@@ -222,6 +245,7 @@ public final class JsonReaderTest extends TestCase {
     assertEquals("$", reader.getPath());
   }
 
+  @Test
   public void testHelloWorld() throws IOException {
     String json = "{\n" +
         "   \"hello\": true,\n" +
@@ -239,6 +263,7 @@ public final class JsonReaderTest extends TestCase {
     assertEquals(JsonToken.END_DOCUMENT, reader.peek());
   }
 
+  @Test
   public void testInvalidJsonInput() throws IOException {
     String json = "{\n"
         + "   \"h\\ello\": true,\n"
@@ -255,6 +280,7 @@ public final class JsonReaderTest extends TestCase {
   }
 
   @SuppressWarnings("unused")
+  @Test
   public void testNulls() {
     try {
       new JsonReader(null);
@@ -263,6 +289,7 @@ public final class JsonReaderTest extends TestCase {
     }
   }
 
+  @Test
   public void testEmptyString() {
     try {
       new JsonReader(reader("")).beginArray();
@@ -276,6 +303,7 @@ public final class JsonReaderTest extends TestCase {
     }
   }
 
+  @Test
   public void testCharacterUnescaping() throws IOException {
     String json = "[\"a\","
         + "\"a\\\"\","
@@ -322,6 +350,7 @@ public final class JsonReaderTest extends TestCase {
     assertEquals(JsonToken.END_DOCUMENT, reader.peek());
   }
 
+  @Test
   public void testUnescapingInvalidCharacters() throws IOException {
     String json = "[\"\\u000g\"]";
     JsonReader reader = new JsonReader(reader(json));
@@ -333,6 +362,7 @@ public final class JsonReaderTest extends TestCase {
     }
   }
 
+  @Test
   public void testUnescapingTruncatedCharacters() throws IOException {
     String json = "[\"\\u000";
     JsonReader reader = new JsonReader(reader(json));
@@ -344,6 +374,7 @@ public final class JsonReaderTest extends TestCase {
     }
   }
 
+  @Test
   public void testUnescapingTruncatedSequence() throws IOException {
     String json = "[\"\\";
     JsonReader reader = new JsonReader(reader(json));
@@ -355,14 +386,16 @@ public final class JsonReaderTest extends TestCase {
     }
   }
 
+  @Test
   public void testIntegersWithFractionalPartSpecified() throws IOException {
     JsonReader reader = new JsonReader(reader("[1.0,1.0,1.0]"));
     reader.beginArray();
-    assertEquals(1.0, reader.nextDouble());
+    assertEquals(1.0, reader.nextDouble(), 0);
     assertEquals(1, reader.nextInt());
     assertEquals(1L, reader.nextLong());
   }
 
+  @Test
   public void testDoubles() throws IOException {
     String json = "[-0.0,"
         + "1.0,"
@@ -384,28 +417,29 @@ public final class JsonReaderTest extends TestCase {
         + "1e+1]";
     JsonReader reader = new JsonReader(reader(json));
     reader.beginArray();
-    assertEquals(-0.0, reader.nextDouble());
-    assertEquals(1.0, reader.nextDouble());
-    assertEquals(1.7976931348623157E308, reader.nextDouble());
-    assertEquals(4.9E-324, reader.nextDouble());
-    assertEquals(0.0, reader.nextDouble());
-    assertEquals(0.0, reader.nextDouble());
-    assertEquals(-0.5, reader.nextDouble());
-    assertEquals(2.2250738585072014E-308, reader.nextDouble());
-    assertEquals(3.141592653589793, reader.nextDouble());
-    assertEquals(2.718281828459045, reader.nextDouble());
-    assertEquals(0.0, reader.nextDouble());
-    assertEquals(0.01, reader.nextDouble());
-    assertEquals(0.0, reader.nextDouble());
-    assertEquals(1.0, reader.nextDouble());
-    assertEquals(1.0, reader.nextDouble());
-    assertEquals(1.0, reader.nextDouble());
-    assertEquals(10.0, reader.nextDouble());
-    assertEquals(10.0, reader.nextDouble());
+    assertEquals(-0.0, reader.nextDouble(), 0);
+    assertEquals(1.0, reader.nextDouble(), 0);
+    assertEquals(1.7976931348623157E308, reader.nextDouble(), 0);
+    assertEquals(4.9E-324, reader.nextDouble(), 0);
+    assertEquals(0.0, reader.nextDouble(), 0);
+    assertEquals(0.0, reader.nextDouble(), 0);
+    assertEquals(-0.5, reader.nextDouble(), 0);
+    assertEquals(2.2250738585072014E-308, reader.nextDouble(), 0);
+    assertEquals(3.141592653589793, reader.nextDouble(), 0);
+    assertEquals(2.718281828459045, reader.nextDouble(), 0);
+    assertEquals(0.0, reader.nextDouble(), 0);
+    assertEquals(0.01, reader.nextDouble(), 0);
+    assertEquals(0.0, reader.nextDouble(), 0);
+    assertEquals(1.0, reader.nextDouble(), 0);
+    assertEquals(1.0, reader.nextDouble(), 0);
+    assertEquals(1.0, reader.nextDouble(), 0);
+    assertEquals(10.0, reader.nextDouble(), 0);
+    assertEquals(10.0, reader.nextDouble(), 0);
     reader.endArray();
     assertEquals(JsonToken.END_DOCUMENT, reader.peek());
   }
 
+  @Test
   public void testStrictNonFiniteDoubles() throws IOException {
     String json = "[NaN]";
     JsonReader reader = new JsonReader(reader(json));
@@ -417,6 +451,7 @@ public final class JsonReaderTest extends TestCase {
     }
   }
 
+  @Test
   public void testStrictQuotedNonFiniteDoubles() throws IOException {
     String json = "[\"NaN\"]";
     JsonReader reader = new JsonReader(reader(json));
@@ -428,28 +463,31 @@ public final class JsonReaderTest extends TestCase {
     }
   }
 
+  @Test
   public void testLenientNonFiniteDoubles() throws IOException {
     String json = "[NaN, -Infinity, Infinity]";
     JsonReader reader = new JsonReader(reader(json));
     reader.setLenient(true);
     reader.beginArray();
     assertTrue(Double.isNaN(reader.nextDouble()));
-    assertEquals(Double.NEGATIVE_INFINITY, reader.nextDouble());
-    assertEquals(Double.POSITIVE_INFINITY, reader.nextDouble());
+    assertEquals(Double.NEGATIVE_INFINITY, reader.nextDouble(), 0);
+    assertEquals(Double.POSITIVE_INFINITY, reader.nextDouble(), 0);
     reader.endArray();
   }
 
+  @Test
   public void testLenientQuotedNonFiniteDoubles() throws IOException {
     String json = "[\"NaN\", \"-Infinity\", \"Infinity\"]";
     JsonReader reader = new JsonReader(reader(json));
     reader.setLenient(true);
     reader.beginArray();
     assertTrue(Double.isNaN(reader.nextDouble()));
-    assertEquals(Double.NEGATIVE_INFINITY, reader.nextDouble());
-    assertEquals(Double.POSITIVE_INFINITY, reader.nextDouble());
+    assertEquals(Double.NEGATIVE_INFINITY, reader.nextDouble(), 0);
+    assertEquals(Double.POSITIVE_INFINITY, reader.nextDouble(), 0);
     reader.endArray();
   }
 
+  @Test
   public void testStrictNonFiniteDoublesWithSkipValue() throws IOException {
     String json = "[NaN]";
     JsonReader reader = new JsonReader(reader(json));
@@ -461,6 +499,7 @@ public final class JsonReaderTest extends TestCase {
     }
   }
 
+  @Test
   public void testLongs() throws IOException {
     String json = "[0,0,0,"
         + "1,1,1,"
@@ -471,13 +510,13 @@ public final class JsonReaderTest extends TestCase {
     reader.beginArray();
     assertEquals(0L, reader.nextLong());
     assertEquals(0, reader.nextInt());
-    assertEquals(0.0, reader.nextDouble());
+    assertEquals(0.0, reader.nextDouble(), 0);
     assertEquals(1L, reader.nextLong());
     assertEquals(1, reader.nextInt());
-    assertEquals(1.0, reader.nextDouble());
+    assertEquals(1.0, reader.nextDouble(), 0);
     assertEquals(-1L, reader.nextLong());
     assertEquals(-1, reader.nextInt());
-    assertEquals(-1.0, reader.nextDouble());
+    assertEquals(-1.0, reader.nextDouble(), 0);
     try {
       reader.nextInt();
       fail();
@@ -494,6 +533,8 @@ public final class JsonReaderTest extends TestCase {
     assertEquals(JsonToken.END_DOCUMENT, reader.peek());
   }
 
+  @Test
+  @Ignore
   public void disabled_testNumberWithOctalPrefix() throws IOException {
     String json = "[01]";
     JsonReader reader = new JsonReader(reader(json));
@@ -523,6 +564,7 @@ public final class JsonReaderTest extends TestCase {
     assertEquals(JsonToken.END_DOCUMENT, reader.peek());
   }
 
+  @Test
   public void testBooleans() throws IOException {
     JsonReader reader = new JsonReader(reader("[true,false]"));
     reader.beginArray();
@@ -532,6 +574,7 @@ public final class JsonReaderTest extends TestCase {
     assertEquals(JsonToken.END_DOCUMENT, reader.peek());
   }
 
+  @Test
   public void testPeekingUnquotedStringsPrefixedWithBooleans() throws IOException {
     JsonReader reader = new JsonReader(reader("[truey]"));
     reader.setLenient(true);
@@ -546,6 +589,7 @@ public final class JsonReaderTest extends TestCase {
     reader.endArray();
   }
 
+  @Test
   public void testMalformedNumbers() throws IOException {
     assertNotANumber("-");
     assertNotANumber(".");
@@ -604,6 +648,7 @@ public final class JsonReaderTest extends TestCase {
     }
   }
 
+  @Test
   public void testPeekingUnquotedStringsPrefixedWithIntegers() throws IOException {
     JsonReader reader = new JsonReader(reader("[12.34e5x]"));
     reader.setLenient(true);
@@ -617,6 +662,7 @@ public final class JsonReaderTest extends TestCase {
     assertEquals("12.34e5x", reader.nextString());
   }
 
+  @Test
   public void testPeekLongMinValue() throws IOException {
     JsonReader reader = new JsonReader(reader("[-9223372036854775808]"));
     reader.setLenient(true);
@@ -625,6 +671,7 @@ public final class JsonReaderTest extends TestCase {
     assertEquals(-9223372036854775808L, reader.nextLong());
   }
 
+  @Test
   public void testPeekLongMaxValue() throws IOException {
     JsonReader reader = new JsonReader(reader("[9223372036854775807]"));
     reader.setLenient(true);
@@ -633,6 +680,7 @@ public final class JsonReaderTest extends TestCase {
     assertEquals(9223372036854775807L, reader.nextLong());
   }
 
+  @Test
   public void testLongLargerThanMaxLongThatWrapsAround() throws IOException {
     JsonReader reader = new JsonReader(reader("[22233720368547758070]"));
     reader.setLenient(true);
@@ -645,6 +693,7 @@ public final class JsonReaderTest extends TestCase {
     }
   }
 
+  @Test
   public void testLongLargerThanMinLongThatWrapsAround() throws IOException {
     JsonReader reader = new JsonReader(reader("[-22233720368547758070]"));
     reader.setLenient(true);
@@ -661,6 +710,7 @@ public final class JsonReaderTest extends TestCase {
    * Issue 1053, negative zero.
    * @throws Exception
    */
+  @Test
   public void testNegativeZero() throws Exception {
     JsonReader reader = new JsonReader(reader("[-0]"));
     reader.setLenient(false);
@@ -673,6 +723,8 @@ public final class JsonReaderTest extends TestCase {
    * This test fails because there's no double for 9223372036854775808, and our
    * long parsing uses Double.parseDouble() for fractional values.
    */
+  @Test
+  @Ignore
   public void disabled_testPeekLargerThanLongMaxValue() throws IOException {
     JsonReader reader = new JsonReader(reader("[9223372036854775808]"));
     reader.setLenient(true);
@@ -689,6 +741,8 @@ public final class JsonReaderTest extends TestCase {
    * This test fails because there's no double for -9223372036854775809, and our
    * long parsing uses Double.parseDouble() for fractional values.
    */
+  @Test
+  @Ignore
   public void disabled_testPeekLargerThanLongMinValue() throws IOException {
     JsonReader reader = new JsonReader(reader("[-9223372036854775809]"));
     reader.setLenient(true);
@@ -699,13 +753,15 @@ public final class JsonReaderTest extends TestCase {
       fail();
     } catch (NumberFormatException expected) {
     }
-    assertEquals(-9223372036854775809d, reader.nextDouble());
+    assertEquals(-9223372036854775809d, reader.nextDouble(), 0);
   }
 
   /**
    * This test fails because there's no double for 9223372036854775806, and
    * our long parsing uses Double.parseDouble() for fractional values.
    */
+  @Test
+  @Ignore
   public void disabled_testHighPrecisionLong() throws IOException {
     String json = "[9223372036854775806.000]";
     JsonReader reader = new JsonReader(reader(json));
@@ -714,6 +770,7 @@ public final class JsonReaderTest extends TestCase {
     reader.endArray();
   }
 
+  @Test
   public void testPeekMuchLargerThanLongMinValue() throws IOException {
     JsonReader reader = new JsonReader(reader("[-92233720368547758080]"));
     reader.setLenient(true);
@@ -724,9 +781,10 @@ public final class JsonReaderTest extends TestCase {
       fail();
     } catch (NumberFormatException expected) {
     }
-    assertEquals(-92233720368547758080d, reader.nextDouble());
+    assertEquals(-92233720368547758080d, reader.nextDouble(), 0);
   }
 
+  @Test
   public void testQuotedNumberWithEscape() throws IOException {
     JsonReader reader = new JsonReader(reader("[\"12\u00334\"]"));
     reader.setLenient(true);
@@ -735,6 +793,7 @@ public final class JsonReaderTest extends TestCase {
     assertEquals(1234, reader.nextInt());
   }
 
+  @Test
   public void testMixedCaseLiterals() throws IOException {
     JsonReader reader = new JsonReader(reader("[True,TruE,False,FALSE,NULL,nulL]"));
     reader.beginArray();
@@ -748,6 +807,7 @@ public final class JsonReaderTest extends TestCase {
     assertEquals(JsonToken.END_DOCUMENT, reader.peek());
   }
 
+  @Test
   public void testMissingValue() throws IOException {
     JsonReader reader = new JsonReader(reader("{\"a\":}"));
     reader.beginObject();
@@ -759,6 +819,7 @@ public final class JsonReaderTest extends TestCase {
     }
   }
 
+  @Test
   public void testPrematureEndOfInput() throws IOException {
     JsonReader reader = new JsonReader(reader("{\"a\":true,"));
     reader.beginObject();
@@ -771,6 +832,7 @@ public final class JsonReaderTest extends TestCase {
     }
   }
 
+  @Test
   public void testPrematurelyClosed() throws IOException {
     try {
       JsonReader reader = new JsonReader(reader("{\"a\":[]}"));
@@ -801,6 +863,7 @@ public final class JsonReaderTest extends TestCase {
     }
   }
 
+  @Test
   public void testNextFailuresDoNotAdvance() throws IOException {
     JsonReader reader = new JsonReader(reader("{\"a\":true}"));
     reader.beginObject();
@@ -861,6 +924,7 @@ public final class JsonReaderTest extends TestCase {
     reader.close();
   }
 
+  @Test
   public void testIntegerMismatchFailuresDoNotAdvance() throws IOException {
     JsonReader reader = new JsonReader(reader("[1.5]"));
     reader.beginArray();
@@ -869,10 +933,11 @@ public final class JsonReaderTest extends TestCase {
       fail();
     } catch (NumberFormatException expected) {
     }
-    assertEquals(1.5d, reader.nextDouble());
+    assertEquals(1.5d, reader.nextDouble(), 0);
     reader.endArray();
   }
 
+  @Test
   public void testStringNullIsNotNull() throws IOException {
     JsonReader reader = new JsonReader(reader("[\"null\"]"));
     reader.beginArray();
@@ -883,6 +948,7 @@ public final class JsonReaderTest extends TestCase {
     }
   }
 
+  @Test
   public void testNullLiteralIsNotAString() throws IOException {
     JsonReader reader = new JsonReader(reader("[null]"));
     reader.beginArray();
@@ -893,6 +959,7 @@ public final class JsonReaderTest extends TestCase {
     }
   }
 
+  @Test
   public void testStrictNameValueSeparator() throws IOException {
     JsonReader reader = new JsonReader(reader("{\"a\"=true}"));
     reader.beginObject();
@@ -913,6 +980,7 @@ public final class JsonReaderTest extends TestCase {
     }
   }
 
+  @Test
   public void testLenientNameValueSeparator() throws IOException {
     JsonReader reader = new JsonReader(reader("{\"a\"=true}"));
     reader.setLenient(true);
@@ -927,6 +995,7 @@ public final class JsonReaderTest extends TestCase {
     assertEquals(true, reader.nextBoolean());
   }
 
+  @Test
   public void testStrictNameValueSeparatorWithSkipValue() throws IOException {
     JsonReader reader = new JsonReader(reader("{\"a\"=true}"));
     reader.beginObject();
@@ -947,6 +1016,7 @@ public final class JsonReaderTest extends TestCase {
     }
   }
 
+  @Test
   public void testCommentsInStringValue() throws Exception {
     JsonReader reader = new JsonReader(reader("[\"// comment\"]"));
     reader.beginArray();
@@ -966,6 +1036,7 @@ public final class JsonReaderTest extends TestCase {
     reader.endObject();
   }
 
+  @Test
   public void testStrictComments() throws IOException {
     JsonReader reader = new JsonReader(reader("[// comment \n true]"));
     reader.beginArray();
@@ -992,6 +1063,7 @@ public final class JsonReaderTest extends TestCase {
     }
   }
 
+  @Test
   public void testLenientComments() throws IOException {
     JsonReader reader = new JsonReader(reader("[// comment \n true]"));
     reader.setLenient(true);
@@ -1009,6 +1081,7 @@ public final class JsonReaderTest extends TestCase {
     assertEquals(true, reader.nextBoolean());
   }
 
+  @Test
   public void testStrictCommentsWithSkipValue() throws IOException {
     JsonReader reader = new JsonReader(reader("[// comment \n true]"));
     reader.beginArray();
@@ -1035,6 +1108,7 @@ public final class JsonReaderTest extends TestCase {
     }
   }
 
+  @Test
   public void testStrictUnquotedNames() throws IOException {
     JsonReader reader = new JsonReader(reader("{a:true}"));
     reader.beginObject();
@@ -1045,6 +1119,7 @@ public final class JsonReaderTest extends TestCase {
     }
   }
 
+  @Test
   public void testLenientUnquotedNames() throws IOException {
     JsonReader reader = new JsonReader(reader("{a:true}"));
     reader.setLenient(true);
@@ -1052,6 +1127,7 @@ public final class JsonReaderTest extends TestCase {
     assertEquals("a", reader.nextName());
   }
 
+  @Test
   public void testStrictUnquotedNamesWithSkipValue() throws IOException {
     JsonReader reader = new JsonReader(reader("{a:true}"));
     reader.beginObject();
@@ -1062,6 +1138,7 @@ public final class JsonReaderTest extends TestCase {
     }
   }
 
+  @Test
   public void testStrictSingleQuotedNames() throws IOException {
     JsonReader reader = new JsonReader(reader("{'a':true}"));
     reader.beginObject();
@@ -1072,6 +1149,7 @@ public final class JsonReaderTest extends TestCase {
     }
   }
 
+  @Test
   public void testLenientSingleQuotedNames() throws IOException {
     JsonReader reader = new JsonReader(reader("{'a':true}"));
     reader.setLenient(true);
@@ -1079,6 +1157,7 @@ public final class JsonReaderTest extends TestCase {
     assertEquals("a", reader.nextName());
   }
 
+  @Test
   public void testStrictSingleQuotedNamesWithSkipValue() throws IOException {
     JsonReader reader = new JsonReader(reader("{'a':true}"));
     reader.beginObject();
@@ -1089,6 +1168,7 @@ public final class JsonReaderTest extends TestCase {
     }
   }
 
+  @Test
   public void testStrictUnquotedStrings() throws IOException {
     JsonReader reader = new JsonReader(reader("[a]"));
     reader.beginArray();
@@ -1099,6 +1179,7 @@ public final class JsonReaderTest extends TestCase {
     }
   }
 
+  @Test
   public void testStrictUnquotedStringsWithSkipValue() throws IOException {
     JsonReader reader = new JsonReader(reader("[a]"));
     reader.beginArray();
@@ -1109,6 +1190,7 @@ public final class JsonReaderTest extends TestCase {
     }
   }
 
+  @Test
   public void testLenientUnquotedStrings() throws IOException {
     JsonReader reader = new JsonReader(reader("[a]"));
     reader.setLenient(true);
@@ -1116,6 +1198,7 @@ public final class JsonReaderTest extends TestCase {
     assertEquals("a", reader.nextString());
   }
 
+  @Test
   public void testStrictSingleQuotedStrings() throws IOException {
     JsonReader reader = new JsonReader(reader("['a']"));
     reader.beginArray();
@@ -1126,6 +1209,7 @@ public final class JsonReaderTest extends TestCase {
     }
   }
 
+  @Test
   public void testLenientSingleQuotedStrings() throws IOException {
     JsonReader reader = new JsonReader(reader("['a']"));
     reader.setLenient(true);
@@ -1133,6 +1217,7 @@ public final class JsonReaderTest extends TestCase {
     assertEquals("a", reader.nextString());
   }
 
+  @Test
   public void testStrictSingleQuotedStringsWithSkipValue() throws IOException {
     JsonReader reader = new JsonReader(reader("['a']"));
     reader.beginArray();
@@ -1143,6 +1228,7 @@ public final class JsonReaderTest extends TestCase {
     }
   }
 
+  @Test
   public void testStrictSemicolonDelimitedArray() throws IOException {
     JsonReader reader = new JsonReader(reader("[true;true]"));
     reader.beginArray();
@@ -1154,6 +1240,7 @@ public final class JsonReaderTest extends TestCase {
     }
   }
 
+  @Test
   public void testLenientSemicolonDelimitedArray() throws IOException {
     JsonReader reader = new JsonReader(reader("[true;true]"));
     reader.setLenient(true);
@@ -1162,6 +1249,7 @@ public final class JsonReaderTest extends TestCase {
     assertEquals(true, reader.nextBoolean());
   }
 
+  @Test
   public void testStrictSemicolonDelimitedArrayWithSkipValue() throws IOException {
     JsonReader reader = new JsonReader(reader("[true;true]"));
     reader.beginArray();
@@ -1173,6 +1261,7 @@ public final class JsonReaderTest extends TestCase {
     }
   }
 
+  @Test
   public void testStrictSemicolonDelimitedNameValuePair() throws IOException {
     JsonReader reader = new JsonReader(reader("{\"a\":true;\"b\":true}"));
     reader.beginObject();
@@ -1185,6 +1274,7 @@ public final class JsonReaderTest extends TestCase {
     }
   }
 
+  @Test
   public void testLenientSemicolonDelimitedNameValuePair() throws IOException {
     JsonReader reader = new JsonReader(reader("{\"a\":true;\"b\":true}"));
     reader.setLenient(true);
@@ -1194,6 +1284,7 @@ public final class JsonReaderTest extends TestCase {
     assertEquals("b", reader.nextName());
   }
 
+  @Test
   public void testStrictSemicolonDelimitedNameValuePairWithSkipValue() throws IOException {
     JsonReader reader = new JsonReader(reader("{\"a\":true;\"b\":true}"));
     reader.beginObject();
@@ -1206,6 +1297,7 @@ public final class JsonReaderTest extends TestCase {
     }
   }
 
+  @Test
   public void testStrictUnnecessaryArraySeparators() throws IOException {
     JsonReader reader = new JsonReader(reader("[true,,true]"));
     reader.beginArray();
@@ -1242,6 +1334,7 @@ public final class JsonReaderTest extends TestCase {
     }
   }
 
+  @Test
   public void testLenientUnnecessaryArraySeparators() throws IOException {
     JsonReader reader = new JsonReader(reader("[true,,true]"));
     reader.setLenient(true);
@@ -1273,6 +1366,7 @@ public final class JsonReaderTest extends TestCase {
     reader.endArray();
   }
 
+  @Test
   public void testStrictUnnecessaryArraySeparatorsWithSkipValue() throws IOException {
     JsonReader reader = new JsonReader(reader("[true,,true]"));
     reader.beginArray();
@@ -1309,6 +1403,7 @@ public final class JsonReaderTest extends TestCase {
     }
   }
 
+  @Test
   public void testStrictMultipleTopLevelValues() throws IOException {
     JsonReader reader = new JsonReader(reader("[] []"));
     reader.beginArray();
@@ -1320,6 +1415,7 @@ public final class JsonReaderTest extends TestCase {
     }
   }
 
+  @Test
   public void testLenientMultipleTopLevelValues() throws IOException {
     JsonReader reader = new JsonReader(reader("[] true {}"));
     reader.setLenient(true);
@@ -1331,6 +1427,7 @@ public final class JsonReaderTest extends TestCase {
     assertEquals(JsonToken.END_DOCUMENT, reader.peek());
   }
 
+  @Test
   public void testStrictMultipleTopLevelValuesWithSkipValue() throws IOException {
     JsonReader reader = new JsonReader(reader("[] []"));
     reader.beginArray();
@@ -1342,6 +1439,7 @@ public final class JsonReaderTest extends TestCase {
     }
   }
 
+  @Test
   public void testTopLevelValueTypes() throws IOException {
     JsonReader reader1 = new JsonReader(reader("true"));
     assertTrue(reader1.nextBoolean());
@@ -1361,7 +1459,7 @@ public final class JsonReaderTest extends TestCase {
     assertEquals(JsonToken.END_DOCUMENT, reader4.peek());
 
     JsonReader reader5 = new JsonReader(reader("123.4"));
-    assertEquals(123.4, reader5.nextDouble());
+    assertEquals(123.4, reader5.nextDouble(), 0);
     assertEquals(JsonToken.END_DOCUMENT, reader5.peek());
 
     JsonReader reader6 = new JsonReader(reader("\"a\""));
@@ -1369,12 +1467,14 @@ public final class JsonReaderTest extends TestCase {
     assertEquals(JsonToken.END_DOCUMENT, reader6.peek());
   }
 
+  @Test
   public void testTopLevelValueTypeWithSkipValue() throws IOException {
     JsonReader reader = new JsonReader(reader("true"));
     reader.skipValue();
     assertEquals(JsonToken.END_DOCUMENT, reader.peek());
   }
 
+  @Test
   public void testStrictNonExecutePrefix() {
     JsonReader reader = new JsonReader(reader(")]}'\n []"));
     try {
@@ -1384,6 +1484,7 @@ public final class JsonReaderTest extends TestCase {
     }
   }
 
+  @Test
   public void testStrictNonExecutePrefixWithSkipValue() {
     JsonReader reader = new JsonReader(reader(")]}'\n []"));
     try {
@@ -1393,6 +1494,7 @@ public final class JsonReaderTest extends TestCase {
     }
   }
 
+  @Test
   public void testLenientNonExecutePrefix() throws IOException {
     JsonReader reader = new JsonReader(reader(")]}'\n []"));
     reader.setLenient(true);
@@ -1401,6 +1503,7 @@ public final class JsonReaderTest extends TestCase {
     assertEquals(JsonToken.END_DOCUMENT, reader.peek());
   }
 
+  @Test
   public void testLenientNonExecutePrefixWithLeadingWhitespace() throws IOException {
     JsonReader reader = new JsonReader(reader("\r\n \t)]}'\n []"));
     reader.setLenient(true);
@@ -1409,6 +1512,7 @@ public final class JsonReaderTest extends TestCase {
     assertEquals(JsonToken.END_DOCUMENT, reader.peek());
   }
 
+  @Test
   public void testLenientPartialNonExecutePrefix() {
     JsonReader reader = new JsonReader(reader(")]}' []"));
     reader.setLenient(true);
@@ -1420,12 +1524,14 @@ public final class JsonReaderTest extends TestCase {
     }
   }
 
+  @Test
   public void testBomIgnoredAsFirstCharacterOfDocument() throws IOException {
     JsonReader reader = new JsonReader(reader("\ufeff[]"));
     reader.beginArray();
     reader.endArray();
   }
 
+  @Test
   public void testBomForbiddenAsOtherCharacterInDocument() throws IOException {
     JsonReader reader = new JsonReader(reader("[\ufeff]"));
     reader.beginArray();
@@ -1436,45 +1542,54 @@ public final class JsonReaderTest extends TestCase {
     }
   }
 
+  @Test
   public void testFailWithPosition() throws IOException {
     testFailWithPosition("Expected value at line 6 column 5 (char '}') path $[1]",
         "[\n\n\n\n\n\"a\",}]");
   }
 
+  @Test
   public void testFailWithPositionGreaterThanBufferSize() throws IOException {
     String spaces = repeat(' ', 8192);
     testFailWithPosition("Expected value at line 6 column 5 (char '}') path $[1]",
         "[\n\n" + spaces + "\n\n\n\"a\",}]");
   }
 
+  @Test
   public void testFailWithPositionOverSlashSlashEndOfLineComment() throws IOException {
     testFailWithPosition("Expected value at line 5 column 6 (char '}') path $[1]",
         "\n// foo\n\n//bar\r\n[\"a\",}");
   }
 
+  @Test
   public void testFailWithPositionOverHashEndOfLineComment() throws IOException {
     testFailWithPosition("Expected value at line 5 column 6 (char '}') path $[1]",
         "\n# foo\n\n#bar\r\n[\"a\",}");
   }
 
+  @Test
   public void testFailWithPositionOverCStyleComment() throws IOException {
     testFailWithPosition("Expected value at line 6 column 12 (char '}') path $[1]",
         "\n\n/* foo\n*\n*\r\nbar */[\"a\",}");
   }
 
+  @Test
   public void testFailWithPositionOverQuotedString() throws IOException {
     testFailWithPosition("Expected value at line 5 column 3 (char '}') path $[1]",
         "[\"foo\nbar\r\nbaz\n\",\n  }");
   }
 
+  @Test
   public void testFailWithPositionOverUnquotedString() throws IOException {
     testFailWithPosition("Expected value at line 5 column 2 (char '}') path $[1]", "[\n\nabcd\n\n,}");
   }
 
+  @Test
   public void testFailWithEscapedNewlineCharacter() throws IOException {
     testFailWithPosition("Expected value at line 5 column 3 (char '}') path $[1]", "[\n\n\"\\\n\n\",}");
   }
 
+  @Test
   public void testFailWithPositionIsOffsetByBom() throws IOException {
     testFailWithPosition("Expected value at line 1 column 6 (char '}') path $[1]",
         "\ufeff[\"a\",}]");
@@ -1506,6 +1621,7 @@ public final class JsonReaderTest extends TestCase {
     }
   }
 
+  @Test
   public void testFailWithPositionDeepPath() throws IOException {
     JsonReader reader = new JsonReader(reader("[1,{\"a\":[2,3,}"));
     reader.beginArray();
@@ -1523,26 +1639,29 @@ public final class JsonReaderTest extends TestCase {
     }
   }
 
+  @Test
   public void testStrictVeryLongNumber() throws IOException {
     JsonReader reader = new JsonReader(reader("[0." + repeat('9', 8192) + "]"));
     reader.beginArray();
     try {
-      assertEquals(1d, reader.nextDouble());
+      assertEquals(1d, reader.nextDouble(), 0);
       fail();
     } catch (MalformedJsonException expected) {
     }
   }
 
+  @Test
   public void testLenientVeryLongNumber() throws IOException {
     JsonReader reader = new JsonReader(reader("[0." + repeat('9', 8192) + "]"));
     reader.setLenient(true);
     reader.beginArray();
     assertEquals(JsonToken.STRING, reader.peek());
-    assertEquals(1d, reader.nextDouble());
+    assertEquals(1d, reader.nextDouble(), 0);
     reader.endArray();
     assertEquals(JsonToken.END_DOCUMENT, reader.peek());
   }
 
+  @Test
   public void testVeryLongUnquotedLiteral() throws IOException {
     String literal = "a" + repeat('b', 8192) + "c";
     JsonReader reader = new JsonReader(reader("[" + literal + "]"));
@@ -1552,6 +1671,7 @@ public final class JsonReaderTest extends TestCase {
     reader.endArray();
   }
 
+  @Test
   public void testDeeplyNestedArrays() throws IOException {
     // this is nested 40 levels deep; Gson is tuned for nesting is 30 levels deep or fewer
     JsonReader reader = new JsonReader(reader(
@@ -1567,6 +1687,7 @@ public final class JsonReaderTest extends TestCase {
     assertEquals(JsonToken.END_DOCUMENT, reader.peek());
   }
 
+  @Test
   public void testDeeplyNestedObjects() throws IOException {
     // Build a JSON document structured like {"a":{"a":{"a":{"a":true}}}}, but 40 levels deep
     String array = "{\"a\":%s}";
@@ -1590,6 +1711,7 @@ public final class JsonReaderTest extends TestCase {
   }
 
   // http://code.google.com/p/google-gson/issues/detail?id=409
+  @Test
   public void testStringEndingInSlash() throws IOException {
     JsonReader reader = new JsonReader(reader("/"));
     reader.setLenient(true);
@@ -1600,6 +1722,7 @@ public final class JsonReaderTest extends TestCase {
     }
   }
 
+  @Test
   public void testDocumentWithCommentEndingInSlash() throws IOException {
     JsonReader reader = new JsonReader(reader("/* foo *//"));
     reader.setLenient(true);
@@ -1610,6 +1733,7 @@ public final class JsonReaderTest extends TestCase {
     }
   }
 
+  @Test
   public void testStringWithLeadingSlash() throws IOException {
     JsonReader reader = new JsonReader(reader("/x"));
     reader.setLenient(true);
@@ -1620,6 +1744,7 @@ public final class JsonReaderTest extends TestCase {
     }
   }
 
+  @Test
   public void testUnterminatedObject() throws IOException {
     JsonReader reader = new JsonReader(reader("{\"a\":\"android\"x"));
     reader.setLenient(true);
@@ -1633,6 +1758,7 @@ public final class JsonReaderTest extends TestCase {
     }
   }
 
+  @Test
   public void testVeryLongQuotedString() throws IOException {
     char[] stringChars = new char[1024 * 16];
     Arrays.fill(stringChars, 'x');
@@ -1644,6 +1770,7 @@ public final class JsonReaderTest extends TestCase {
     reader.endArray();
   }
 
+  @Test
   public void testVeryLongUnquotedString() throws IOException {
     char[] stringChars = new char[1024 * 16];
     Arrays.fill(stringChars, 'x');
@@ -1656,6 +1783,7 @@ public final class JsonReaderTest extends TestCase {
     reader.endArray();
   }
 
+  @Test
   public void testVeryLongUnterminatedString() throws IOException {
     char[] stringChars = new char[1024 * 16];
     Arrays.fill(stringChars, 'x');
@@ -1672,6 +1800,7 @@ public final class JsonReaderTest extends TestCase {
     }
   }
 
+  @Test
   public void testSkipVeryLongUnquotedString() throws IOException {
     JsonReader reader = new JsonReader(reader("[" + repeat('x', 8192) + "]"));
     reader.setLenient(true);
@@ -1680,6 +1809,7 @@ public final class JsonReaderTest extends TestCase {
     reader.endArray();
   }
 
+  @Test
   public void testSkipTopLevelUnquotedString() throws IOException {
     JsonReader reader = new JsonReader(reader(repeat('x', 8192)));
     reader.setLenient(true);
@@ -1687,6 +1817,7 @@ public final class JsonReaderTest extends TestCase {
     assertEquals(JsonToken.END_DOCUMENT, reader.peek());
   }
 
+  @Test
   public void testSkipVeryLongQuotedString() throws IOException {
     JsonReader reader = new JsonReader(reader("[\"" + repeat('x', 8192) + "\"]"));
     reader.beginArray();
@@ -1694,6 +1825,7 @@ public final class JsonReaderTest extends TestCase {
     reader.endArray();
   }
 
+  @Test
   public void testSkipTopLevelQuotedString() throws IOException {
     JsonReader reader = new JsonReader(reader("\"" + repeat('x', 8192) + "\""));
     reader.setLenient(true);
@@ -1701,6 +1833,7 @@ public final class JsonReaderTest extends TestCase {
     assertEquals(JsonToken.END_DOCUMENT, reader.peek());
   }
 
+  @Test
   public void testStringAsNumberWithTruncatedExponent() throws IOException {
     JsonReader reader = new JsonReader(reader("[123e]"));
     reader.setLenient(true);
@@ -1708,6 +1841,7 @@ public final class JsonReaderTest extends TestCase {
     assertEquals(STRING, reader.peek());
   }
 
+  @Test
   public void testStringAsNumberWithDigitAndNonDigitExponent() throws IOException {
     JsonReader reader = new JsonReader(reader("[123e4b]"));
     reader.setLenient(true);
@@ -1715,6 +1849,7 @@ public final class JsonReaderTest extends TestCase {
     assertEquals(STRING, reader.peek());
   }
 
+  @Test
   public void testStringAsNumberWithNonDigitExponent() throws IOException {
     JsonReader reader = new JsonReader(reader("[123eb]"));
     reader.setLenient(true);
@@ -1722,6 +1857,7 @@ public final class JsonReaderTest extends TestCase {
     assertEquals(STRING, reader.peek());
   }
 
+  @Test
   public void testEmptyStringName() throws IOException {
     JsonReader reader = new JsonReader(reader("{\"\":true}"));
     reader.setLenient(true);
@@ -1736,6 +1872,7 @@ public final class JsonReaderTest extends TestCase {
     assertEquals(JsonToken.END_DOCUMENT, reader.peek());
   }
 
+  @Test
   public void testStrictExtraCommasInMaps() throws IOException {
     JsonReader reader = new JsonReader(reader("{\"a\":\"b\",}"));
     reader.beginObject();
@@ -1748,6 +1885,7 @@ public final class JsonReaderTest extends TestCase {
     }
   }
 
+  @Test
   public void testLenientExtraCommasInMaps() throws IOException {
     JsonReader reader = new JsonReader(reader("{\"a\":\"b\",}"));
     reader.setLenient(true);
@@ -1767,6 +1905,7 @@ public final class JsonReaderTest extends TestCase {
     return new String(array);
   }
 
+  @Test
   public void testMalformedDocuments() throws IOException {
     assertDocument("{]", BEGIN_OBJECT, IOException.class);
     assertDocument("{,", BEGIN_OBJECT, IOException.class);
@@ -1813,6 +1952,7 @@ public final class JsonReaderTest extends TestCase {
    * This test behave slightly differently in Gson 2.2 and earlier. It fails
    * during peek rather than during nextString().
    */
+  @Test
   public void testUnterminatedStringFailure() throws IOException {
     JsonReader reader = new JsonReader(reader("[\"string"));
     reader.setLenient(true);
@@ -1828,6 +1968,7 @@ public final class JsonReaderTest extends TestCase {
   /**
    * Regression test for an issue with buffer filling and consumeNonExecutePrefix.
    */
+  @Test
   public void testReadAcrossBuffers() throws IOException {
     StringBuilder sb = new StringBuilder("#");
     for (int i = 0; i < JsonReader.BUFFER_SIZE - 3; i++) {
diff --git a/gson/src/test/java/com/google/gson/stream/JsonWriterTest.java b/gson/src/test/java/com/google/gson/stream/JsonWriterTest.java
index 5c57fd1d..20c4558c 100644
--- a/gson/src/test/java/com/google/gson/stream/JsonWriterTest.java
+++ b/gson/src/test/java/com/google/gson/stream/JsonWriterTest.java
@@ -16,16 +16,20 @@
 
 package com.google.gson.stream;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
 import com.google.gson.internal.LazilyParsedNumber;
 import java.io.IOException;
 import java.io.StringWriter;
 import java.math.BigDecimal;
 import java.math.BigInteger;
-import junit.framework.TestCase;
+import org.junit.Test;
 
 @SuppressWarnings("resource")
-public final class JsonWriterTest extends TestCase {
+public final class JsonWriterTest {
 
+  @Test
   public void testTopLevelValueTypes() throws IOException {
     StringWriter string1 = new StringWriter();
     JsonWriter writer1 = new JsonWriter(string1);
@@ -58,6 +62,7 @@ public final class JsonWriterTest extends TestCase {
     assertEquals("\"a\"", string5.toString());
   }
 
+  @Test
   public void testInvalidTopLevelTypes() throws IOException {
     StringWriter stringWriter = new StringWriter();
     JsonWriter jsonWriter = new JsonWriter(stringWriter);
@@ -69,6 +74,7 @@ public final class JsonWriterTest extends TestCase {
     }
   }
 
+  @Test
   public void testTwoNames() throws IOException {
     StringWriter stringWriter = new StringWriter();
     JsonWriter jsonWriter = new JsonWriter(stringWriter);
@@ -81,6 +87,7 @@ public final class JsonWriterTest extends TestCase {
     }
   }
 
+  @Test
   public void testNameWithoutValue() throws IOException {
     StringWriter stringWriter = new StringWriter();
     JsonWriter jsonWriter = new JsonWriter(stringWriter);
@@ -93,6 +100,7 @@ public final class JsonWriterTest extends TestCase {
     }
   }
 
+  @Test
   public void testValueWithoutName() throws IOException {
     StringWriter stringWriter = new StringWriter();
     JsonWriter jsonWriter = new JsonWriter(stringWriter);
@@ -104,6 +112,7 @@ public final class JsonWriterTest extends TestCase {
     }
   }
 
+  @Test
   public void testMultipleTopLevelValues() throws IOException {
     StringWriter stringWriter = new StringWriter();
     JsonWriter jsonWriter = new JsonWriter(stringWriter);
@@ -115,6 +124,7 @@ public final class JsonWriterTest extends TestCase {
     }
   }
 
+  @Test
   public void testBadNestingObject() throws IOException {
     StringWriter stringWriter = new StringWriter();
     JsonWriter jsonWriter = new JsonWriter(stringWriter);
@@ -127,6 +137,7 @@ public final class JsonWriterTest extends TestCase {
     }
   }
 
+  @Test
   public void testBadNestingArray() throws IOException {
     StringWriter stringWriter = new StringWriter();
     JsonWriter jsonWriter = new JsonWriter(stringWriter);
@@ -139,6 +150,7 @@ public final class JsonWriterTest extends TestCase {
     }
   }
 
+  @Test
   public void testNullName() throws IOException {
     StringWriter stringWriter = new StringWriter();
     JsonWriter jsonWriter = new JsonWriter(stringWriter);
@@ -150,6 +162,7 @@ public final class JsonWriterTest extends TestCase {
     }
   }
 
+  @Test
   public void testNullStringValue() throws IOException {
     StringWriter stringWriter = new StringWriter();
     JsonWriter jsonWriter = new JsonWriter(stringWriter);
@@ -160,6 +173,7 @@ public final class JsonWriterTest extends TestCase {
     assertEquals("{\"a\":null}", stringWriter.toString());
   }
 
+  @Test
   public void testJsonValue() throws IOException {
     StringWriter stringWriter = new StringWriter();
     JsonWriter jsonWriter = new JsonWriter(stringWriter);
@@ -172,6 +186,7 @@ public final class JsonWriterTest extends TestCase {
     assertEquals("{\"a\":{\"b\":true},\"c\":1}", stringWriter.toString());
   }
 
+  @Test
   public void testNonFiniteFloats() throws IOException {
     StringWriter stringWriter = new StringWriter();
     JsonWriter jsonWriter = new JsonWriter(stringWriter);
@@ -196,6 +211,7 @@ public final class JsonWriterTest extends TestCase {
     }
   }
 
+  @Test
   public void testNonFiniteDoubles() throws IOException {
     StringWriter stringWriter = new StringWriter();
     JsonWriter jsonWriter = new JsonWriter(stringWriter);
@@ -220,6 +236,7 @@ public final class JsonWriterTest extends TestCase {
     }
   }
 
+  @Test
   public void testNonFiniteNumbers() throws IOException {
     StringWriter stringWriter = new StringWriter();
     JsonWriter jsonWriter = new JsonWriter(stringWriter);
@@ -250,6 +267,7 @@ public final class JsonWriterTest extends TestCase {
     }
   }
 
+  @Test
   public void testNonFiniteFloatsWhenLenient() throws IOException {
     StringWriter stringWriter = new StringWriter();
     JsonWriter jsonWriter = new JsonWriter(stringWriter);
@@ -262,6 +280,7 @@ public final class JsonWriterTest extends TestCase {
     assertEquals("[NaN,-Infinity,Infinity]", stringWriter.toString());
   }
 
+  @Test
   public void testNonFiniteDoublesWhenLenient() throws IOException {
     StringWriter stringWriter = new StringWriter();
     JsonWriter jsonWriter = new JsonWriter(stringWriter);
@@ -274,6 +293,7 @@ public final class JsonWriterTest extends TestCase {
     assertEquals("[NaN,-Infinity,Infinity]", stringWriter.toString());
   }
 
+  @Test
   public void testNonFiniteNumbersWhenLenient() throws IOException {
     StringWriter stringWriter = new StringWriter();
     JsonWriter jsonWriter = new JsonWriter(stringWriter);
@@ -287,6 +307,7 @@ public final class JsonWriterTest extends TestCase {
     assertEquals("[NaN,-Infinity,Infinity,Infinity]", stringWriter.toString());
   }
 
+  @Test
   public void testFloats() throws IOException {
     StringWriter stringWriter = new StringWriter();
     JsonWriter jsonWriter = new JsonWriter(stringWriter);
@@ -317,6 +338,7 @@ public final class JsonWriterTest extends TestCase {
         stringWriter.toString());
   }
 
+  @Test
   public void testDoubles() throws IOException {
     StringWriter stringWriter = new StringWriter();
     JsonWriter jsonWriter = new JsonWriter(stringWriter);
@@ -343,6 +365,7 @@ public final class JsonWriterTest extends TestCase {
         + "2.718281828459045]", stringWriter.toString());
   }
 
+  @Test
   public void testLongs() throws IOException {
     StringWriter stringWriter = new StringWriter();
     JsonWriter jsonWriter = new JsonWriter(stringWriter);
@@ -361,6 +384,7 @@ public final class JsonWriterTest extends TestCase {
         + "9223372036854775807]", stringWriter.toString());
   }
 
+  @Test
   public void testNumbers() throws IOException {
     StringWriter stringWriter = new StringWriter();
     JsonWriter jsonWriter = new JsonWriter(stringWriter);
@@ -380,6 +404,7 @@ public final class JsonWriterTest extends TestCase {
   /**
    * Tests writing {@code Number} instances which are not one of the standard JDK ones.
    */
+  @Test
   public void testNumbersCustomClass() throws IOException {
     String[] validNumbers = {
         "-0.0",
@@ -413,6 +438,7 @@ public final class JsonWriterTest extends TestCase {
     }
   }
 
+  @Test
   public void testMalformedNumbers() throws IOException {
     String[] malformedNumbers = {
         "some text",
@@ -452,6 +478,7 @@ public final class JsonWriterTest extends TestCase {
     }
   }
 
+  @Test
   public void testBooleans() throws IOException {
     StringWriter stringWriter = new StringWriter();
     JsonWriter jsonWriter = new JsonWriter(stringWriter);
@@ -462,6 +489,7 @@ public final class JsonWriterTest extends TestCase {
     assertEquals("[true,false]", stringWriter.toString());
   }
 
+  @Test
   public void testBoxedBooleans() throws IOException {
     StringWriter stringWriter = new StringWriter();
     JsonWriter jsonWriter = new JsonWriter(stringWriter);
@@ -473,6 +501,7 @@ public final class JsonWriterTest extends TestCase {
     assertEquals("[true,false,null]", stringWriter.toString());
   }
 
+  @Test
   public void testNulls() throws IOException {
     StringWriter stringWriter = new StringWriter();
     JsonWriter jsonWriter = new JsonWriter(stringWriter);
@@ -482,6 +511,7 @@ public final class JsonWriterTest extends TestCase {
     assertEquals("[null]", stringWriter.toString());
   }
 
+  @Test
   public void testStrings() throws IOException {
     StringWriter stringWriter = new StringWriter();
     JsonWriter jsonWriter = new JsonWriter(stringWriter);
@@ -525,6 +555,7 @@ public final class JsonWriterTest extends TestCase {
         + "\"\\u0019\"]", stringWriter.toString());
   }
 
+  @Test
   public void testUnicodeLineBreaksEscaped() throws IOException {
     StringWriter stringWriter = new StringWriter();
     JsonWriter jsonWriter = new JsonWriter(stringWriter);
@@ -534,6 +565,7 @@ public final class JsonWriterTest extends TestCase {
     assertEquals("[\"\\u2028 \\u2029\"]", stringWriter.toString());
   }
 
+  @Test
   public void testEmptyArray() throws IOException {
     StringWriter stringWriter = new StringWriter();
     JsonWriter jsonWriter = new JsonWriter(stringWriter);
@@ -542,6 +574,7 @@ public final class JsonWriterTest extends TestCase {
     assertEquals("[]", stringWriter.toString());
   }
 
+  @Test
   public void testEmptyObject() throws IOException {
     StringWriter stringWriter = new StringWriter();
     JsonWriter jsonWriter = new JsonWriter(stringWriter);
@@ -550,6 +583,7 @@ public final class JsonWriterTest extends TestCase {
     assertEquals("{}", stringWriter.toString());
   }
 
+  @Test
   public void testObjectsInArrays() throws IOException {
     StringWriter stringWriter = new StringWriter();
     JsonWriter jsonWriter = new JsonWriter(stringWriter);
@@ -567,6 +601,7 @@ public final class JsonWriterTest extends TestCase {
         + "{\"c\":6,\"d\":true}]", stringWriter.toString());
   }
 
+  @Test
   public void testArraysInObjects() throws IOException {
     StringWriter stringWriter = new StringWriter();
     JsonWriter jsonWriter = new JsonWriter(stringWriter);
@@ -586,6 +621,7 @@ public final class JsonWriterTest extends TestCase {
         + "\"b\":[6,true]}", stringWriter.toString());
   }
 
+  @Test
   public void testDeepNestingArrays() throws IOException {
     StringWriter stringWriter = new StringWriter();
     JsonWriter jsonWriter = new JsonWriter(stringWriter);
@@ -598,6 +634,7 @@ public final class JsonWriterTest extends TestCase {
     assertEquals("[[[[[[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]]]]]", stringWriter.toString());
   }
 
+  @Test
   public void testDeepNestingObjects() throws IOException {
     StringWriter stringWriter = new StringWriter();
     JsonWriter jsonWriter = new JsonWriter(stringWriter);
@@ -615,6 +652,7 @@ public final class JsonWriterTest extends TestCase {
         + "}}}}}}}}}}}}}}}}}}}}}", stringWriter.toString());
   }
 
+  @Test
   public void testRepeatedName() throws IOException {
     StringWriter stringWriter = new StringWriter();
     JsonWriter jsonWriter = new JsonWriter(stringWriter);
@@ -626,6 +664,7 @@ public final class JsonWriterTest extends TestCase {
     assertEquals("{\"a\":true,\"a\":false}", stringWriter.toString());
   }
 
+  @Test
   public void testPrettyPrintObject() throws IOException {
     StringWriter stringWriter = new StringWriter();
     JsonWriter jsonWriter = new JsonWriter(stringWriter);
@@ -663,6 +702,7 @@ public final class JsonWriterTest extends TestCase {
     assertEquals(expected, stringWriter.toString());
   }
 
+  @Test
   public void testPrettyPrintArray() throws IOException {
     StringWriter stringWriter = new StringWriter();
     JsonWriter jsonWriter = new JsonWriter(stringWriter);
@@ -700,6 +740,7 @@ public final class JsonWriterTest extends TestCase {
     assertEquals(expected, stringWriter.toString());
   }
 
+  @Test
   public void testLenientWriterPermitsMultipleTopLevelValues() throws IOException {
     StringWriter stringWriter = new StringWriter();
     JsonWriter writer = new JsonWriter(stringWriter);
@@ -712,6 +753,7 @@ public final class JsonWriterTest extends TestCase {
     assertEquals("[][]", stringWriter.toString());
   }
 
+  @Test
   public void testStrictWriterDoesNotPermitMultipleTopLevelValues() throws IOException {
     StringWriter stringWriter = new StringWriter();
     JsonWriter writer = new JsonWriter(stringWriter);
@@ -724,6 +766,7 @@ public final class JsonWriterTest extends TestCase {
     }
   }
 
+  @Test
   public void testClosedWriterThrowsOnStructure() throws IOException {
     StringWriter stringWriter = new StringWriter();
     JsonWriter writer = new JsonWriter(stringWriter);
@@ -752,6 +795,7 @@ public final class JsonWriterTest extends TestCase {
     }
   }
 
+  @Test
   public void testClosedWriterThrowsOnName() throws IOException {
     StringWriter stringWriter = new StringWriter();
     JsonWriter writer = new JsonWriter(stringWriter);
@@ -765,6 +809,7 @@ public final class JsonWriterTest extends TestCase {
     }
   }
 
+  @Test
   public void testClosedWriterThrowsOnValue() throws IOException {
     StringWriter stringWriter = new StringWriter();
     JsonWriter writer = new JsonWriter(stringWriter);
@@ -778,6 +823,7 @@ public final class JsonWriterTest extends TestCase {
     }
   }
 
+  @Test
   public void testClosedWriterThrowsOnFlush() throws IOException {
     StringWriter stringWriter = new StringWriter();
     JsonWriter writer = new JsonWriter(stringWriter);
@@ -791,6 +837,7 @@ public final class JsonWriterTest extends TestCase {
     }
   }
 
+  @Test
   public void testWriterCloseIsIdempotent() throws IOException {
     StringWriter stringWriter = new StringWriter();
     JsonWriter writer = new JsonWriter(stringWriter);
diff --git a/pom.xml b/pom.xml
index feea7db4..a86c9867 100644
--- a/pom.xml
+++ b/pom.xml
@@ -5,7 +5,7 @@
 
   <groupId>io.gitlab.jfronny</groupId>
   <artifactId>gson-parent</artifactId>
-  <version>2.11.0-SNAPSHOT</version>
+  <version>2.10.2-SNAPSHOT</version>
   <packaging>pom</packaging>
 
   <name>Gson Parent</name>