diff --git a/.git-blame-ignore-revs b/.git-blame-ignore-revs
new file mode 100644
index 000000000..285ed6f41
--- /dev/null
+++ b/.git-blame-ignore-revs
@@ -0,0 +1,2 @@
+# Scala Steward: Reformat with scalafmt 3.9.9
+424ec59eb4865feb383ca53b4278dfb8b9b6c36c
diff --git a/.github/dependabot.yml b/.github/dependabot.yml
new file mode 100644
index 000000000..5ace4600a
--- /dev/null
+++ b/.github/dependabot.yml
@@ -0,0 +1,6 @@
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"
diff --git a/.github/release-drafter.yml b/.github/release-drafter.yml
new file mode 100644
index 000000000..fb21a72b5
--- /dev/null
+++ b/.github/release-drafter.yml
@@ -0,0 +1,62 @@
+name-template: 'v$RESOLVED_VERSION'
+tag-template: 'v$RESOLVED_VERSION'
+categories:
+  - title: '🔥 Breaking Changes'
+    labels:
+      - 'breaking'
+  - title: '🚀 Features'
+    labels:
+      - 'feature'
+      - 'enhancement'
+  - title: '🐛 Bug Fixes'
+    labels:
+      - 'bug'
+  - title: '👋 Deprecated'
+    labels:
+      - 'deprecation'
+  - title: '🔗 Dependency Updates'
+    labels:
+      - 'library-update'
+      - 'dependencies'
+  - title: '🛠  Internal Updates'
+    labels:
+      - 'internal'
+      - 'kaizen'
+      - 'test-library-update'
+      - 'sbt-plugin-update'
+  - title: '📚 Docs'
+    labels:
+      - 'doc'
+change-template: '- $TITLE @$AUTHOR (#$NUMBER)'
+
+template: |
+  ## What's Changed
+
+  $CHANGES
+
+  **Full Changelog**: https://github.com/$OWNER/$REPOSITORY/compare/$PREVIOUS_TAG...v$RESOLVED_VERSION
+
+
+autolabeler:
+  - label: 'doc'
+    files:
+      - '*.md'
+  - label: 'feature'
+    title:
+      - '/(feature|support)/i'
+  - label: 'bug'
+    title:
+      - '/(fix|bug)/i'
+  - label: 'internal'
+    title:
+      - '/internal/i'
+  - label: 'deprecation'
+    title:
+      - '/deprecate/i'
+  - label: 'library-update'
+    body:
+      - '/library-update/'
+  - label: 'internal'
+    body:
+      - '/test-library-update/'
+      - '/sbt-plugin-update/'
diff --git a/.github/release.yml b/.github/release.yml
new file mode 100644
index 000000000..973c3db68
--- /dev/null
+++ b/.github/release.yml
@@ -0,0 +1,31 @@
+changelog:
+  categories:
+    - title: '🔥 Breaking Changes'
+      labels:
+        - 'breaking'
+    - title: '👋 Deprecated'
+      labels:
+        - 'deprecation'
+    - title: '🚀 Features'
+      labels:
+        - 'feature'
+        - 'enhancement'
+    - title: '🐛 Bug Fixes'
+      labels:
+        - 'bug'
+    - title: '🔗 Dependency Updates'
+      labels:
+        - 'library-update'
+        - 'dependencies'
+    - title: '🛠  Internal Updates'
+      labels:
+        - 'internal'
+        - 'kaizen'
+        - 'test-library-update'
+        - 'sbt-plugin-update'
+    - title: '📚 Docs'
+      labels:
+        - 'doc'
+    - title: Other Changes
+      labels:
+        - "*"
diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml
index f289bc708..091ca0deb 100644
--- a/.github/workflows/CI.yml
+++ b/.github/workflows/CI.yml
@@ -2,61 +2,69 @@ name: CI
 
 on:
   pull_request:
-    paths:
-      - '**.scala'
-      - '**.java'
-      - '**.sbt'
-      - '.github/workflows/**.yml'
   push:
     branches:
-      - master
-      - develop
       - main
-    paths:
-      - '**.scala'
-      - '**.java'
-      - '**.sbt'
-      - '.github/workflows/**.yml'
+  workflow_dispatch:
 
 jobs:
+  changes:
+    runs-on: ubuntu-latest
+    outputs:
+      code: ${{ steps.changes.outputs.code }}
+      docs: ${{ steps.changes.outputs.docs }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v5
+      - uses: dorny/paths-filter@v3
+        id: changes
+        with:
+          filters: |
+            code:
+              - '**.scala'
+              - '**.java'
+              - '**.sbt'
+              - '.github/workflows/**.yml'
+              - 'project/build.properties'
+              - 'msgpack-core/**'
+              - 'msgpack-jackson/**'
+            docs:
+              - '**.md'
+              - '**.txt'
+              - 'LICENSE'
+
   code_format:
     name: Code Format
     runs-on: ubuntu-latest
+    needs: changes
+    if: ${{ needs.changes.outputs.code == 'true' }}
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v5
       - name: jcheckstyle
         run: ./sbt jcheckStyle
-  test_jdk11:
-    name: Test JDK11
+      - name: scalafmtCheckAll
+        run: ./sbt scalafmtCheckAll
+  
+  test:
+    name: Test JDK${{ matrix.java }}
     runs-on: ubuntu-latest
+    needs: changes
+    if: ${{ needs.changes.outputs.code == 'true' }}
+    strategy:
+      matrix:
+        java: ['8', '11', '17', '21', '24']
     steps:
-      - uses: actions/checkout@v2
-      - uses: olafurpg/setup-scala@v10
+      - uses: actions/checkout@v5
+      - uses: actions/setup-java@v5
         with:
-          java-version: adopt@1.11
-      - uses: actions/cache@v2
+          distribution: 'zulu'
+          java-version: ${{ matrix.java }}
+      - uses: actions/cache@v4
         with:
           path: ~/.cache
-          key: ${{ runner.os }}-jdk11-${{ hashFiles('**/*.sbt') }}
-          restore-keys: ${{ runner.os }}-jdk11-
+          key: ${{ runner.os }}-jdk${{ matrix.java }}-${{ hashFiles('**/*.sbt') }}
+          restore-keys: ${{ runner.os }}-jdk${{ matrix.java }}-
       - name: Test
         run: ./sbt test
       - name: Universal Buffer Test
-        run: ./sbt test -J-Dmsgpack.universal-buffer=true
-  test_jdk8:
-    name: Test JDK8
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - uses: olafurpg/setup-scala@v10
-        with:
-          java-version: adopt@1.8
-      - uses: actions/cache@v2
-        with:
-          path: ~/.cache
-          key: ${{ runner.os }}-jdk8-${{ hashFiles('**/*.sbt') }}
-          restore-keys: ${{ runner.os }}-jdk8-
-      - name: Test
-        run: ./sbt test
-      - name: Universal    Buffer Test
-        run: ./sbt test -J-Dmsgpack.universal-buffer=true
+        run: ./sbt test -J-Dmsgpack.universal-buffer=true
\ No newline at end of file
diff --git a/.github/workflows/release-drafter.yml b/.github/workflows/release-drafter.yml
new file mode 100644
index 000000000..f77373a9b
--- /dev/null
+++ b/.github/workflows/release-drafter.yml
@@ -0,0 +1,27 @@
+name: Release Drafter
+
+on:
+  # pull_request event is required only for autolabeler
+  pull_request:
+    # Only following types are handled by the action, but one can default to all as well
+    types: [opened, reopened, synchronize]
+  # pull_request_target event is required for autolabeler to support PRs from forks
+  pull_request_target:
+    types: [opened, reopened, synchronize]
+
+permissions:
+  contents: read
+
+jobs:
+  update_release_draft:
+    permissions:
+      contents: read
+      # write permission is required for autolabeler
+      # otherwise, read permission is required at least
+      pull-requests: write
+    runs-on: ubuntu-latest
+    steps:
+      # Drafts your next Release notes as Pull Requests are merged into "master"
+      - uses: release-drafter/release-drafter@v6
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
diff --git a/.github/workflows/release-note.yml b/.github/workflows/release-note.yml
new file mode 100644
index 000000000..ac290e4c6
--- /dev/null
+++ b/.github/workflows/release-note.yml
@@ -0,0 +1,18 @@
+name: Release Note
+
+on:
+  push:
+    tags:
+      - v*
+  workflow_dispatch:      
+
+jobs:
+  release:
+    name: Create a new release note
+    runs-on: ubuntu-latest
+    steps:         
+      - name: Create a release note
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          gh release create "$GITHUB_REF_NAME" --repo="$GITHUB_REPOSITORY" --generate-notes
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index d105d9d1b..16adf80f0 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -11,16 +11,17 @@ jobs:
     name: Release
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v5
         with:
           fetch-depth: 10000
       # Fetch all tags so that sbt-dynver can find the previous release version
       - run: git fetch --tags -f
       # Install OpenJDK 8
-      - uses: olafurpg/setup-scala@v10
+      - uses: actions/setup-java@v5
         with:
           # We need to use JDK8 for Android compatibility https://github.com/msgpack/msgpack-java/issues/516
-          java-version: adopt@1.8
+          java-version: 8
+          distribution: adopt
       - name: Setup GPG
         env:
           PGP_SECRET: ${{ secrets.PGP_SECRET }}
@@ -32,6 +33,6 @@ jobs:
           ./sbt publishSigned
       - name: Release to Sonatype
         env:
-          SONATYPE_USERNAME: '${{ secrets.SONATYPE_USER }}'
-          SONATYPE_PASSWORD: '${{ secrets.SONATYPE_PASS }}'
-        run: ./sbt sonatypeBundleRelease
+          SONATYPE_USERNAME: '${{ secrets.SONATYPE_USERNAME }}'
+          SONATYPE_PASSWORD: '${{ secrets.SONATYPE_PASSWORD }}'
+        run: ./sbt sonaRelease
diff --git a/.github/workflows/snapshot.yml b/.github/workflows/snapshot.yml
index 1fde65f15..749e61759 100644
--- a/.github/workflows/snapshot.yml
+++ b/.github/workflows/snapshot.yml
@@ -3,7 +3,6 @@ name: Snapshot Release
 on:
   push:
     branches:
-      - develop
       - main
     paths:
       - '**.scala'
@@ -17,16 +16,17 @@ jobs:
     name: Publish snapshots
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v5
         with:
           fetch-depth: 10000
       # Fetch all tags so that sbt-dynver can find the previous release version
       - run: git fetch --tags
-      - uses: olafurpg/setup-scala@v10
+      - uses: actions/setup-java@v5
         with:
-          java-version: adopt@1.11
+          java-version: 11
+          distribution: adopt
       - name: Publish snapshots
         env:
-          SONATYPE_USERNAME: '${{ secrets.SONATYPE_USER }}'
-          SONATYPE_PASSWORD: '${{ secrets.SONATYPE_PASS }}'
+          SONATYPE_USERNAME: '${{ secrets.SONATYPE_USERNAME }}'
+          SONATYPE_PASSWORD: '${{ secrets.SONATYPE_PASSWORD }}'
         run: ./sbt publish
diff --git a/.scalafmt.conf b/.scalafmt.conf
index bda502a5c..a4b995aac 100644
--- a/.scalafmt.conf
+++ b/.scalafmt.conf
@@ -1,3 +1,17 @@
-maxColumn = 180
+version = 3.9.9
+project.layout = StandardConvention
+runner.dialect = scala3
+maxColumn = 100
 style = defaultWithAlign
+docstrings.blankFirstLine = yes
+rewrite.scala3.convertToNewSyntax = true
+rewrite.scala3.removeOptionalBraces = yes
+rewrite.scala3.insertEndMarkerMinLines = 30
+# Add a new line before case class
+newlines.topLevelStatementBlankLines = [
+  {
+    blanks { after = 1 }
+  }
+]
+newlines.source = unfold
 optIn.breaksInsideChains = true
diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 000000000..2e72e982e
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1,93 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+MessagePack-Java is a binary serialization library that provides a fast and compact alternative to JSON. The project consists of two main modules:
+- **msgpack-core**: Standalone MessagePack implementation with no external dependencies
+- **msgpack-jackson**: Jackson integration for object mapping capabilities
+
+## Essential Development Commands
+
+### Build and Compile
+```bash
+./sbt compile              # Compile source code
+./sbt "Test / compile"     # Compile source and test code
+./sbt package              # Create JAR files
+```
+
+### Testing
+```bash
+./sbt test                 # Run all tests
+./sbt ~test                # Run tests continuously on file changes
+./sbt testOnly *TestClass  # Run specific test class
+./sbt "testOnly *TestClass -- -z pattern"  # Run tests matching pattern
+
+# Test with universal buffer mode (for compatibility testing)
+./sbt test -J-Dmsgpack.universal-buffer=true
+```
+
+### Code Quality
+```bash
+./sbt jcheckStyle          # Run checkstyle (Facebook Presto style)
+./sbt scalafmtAll          # Format all Scala and sbt code
+```
+
+### Publishing
+```bash
+./sbt publishLocal         # Install to local .ivy2 repository
+./sbt publishM2            # Install to local .m2 Maven repository
+```
+
+## Architecture Overview
+
+### Core API Structure
+The main entry point is the `MessagePack` factory class which creates:
+- **MessagePacker**: Serializes objects to MessagePack binary format
+- **MessageUnpacker**: Deserializes MessagePack binary data
+
+Key locations:
+- Core interfaces: `msgpack-core/src/main/java/org/msgpack/core/`
+- Jackson integration: `msgpack-jackson/src/main/java/org/msgpack/jackson/dataformat/`
+
+### Buffer Management System
+MessagePack uses an efficient buffer abstraction layer:
+- **MessageBuffer**: Platform-optimized buffer implementations
+  - Uses `sun.misc.Unsafe` for performance when available
+  - Falls back to ByteBuffer on restricted platforms
+- **MessageBufferInput/Output**: Manages buffer sequences for streaming
+
+### Jackson Integration
+The msgpack-jackson module provides:
+- **MessagePackFactory**: Jackson JsonFactory implementation
+- **MessagePackMapper**: Pre-configured ObjectMapper for MessagePack
+- Support for field IDs (integer keys) for compact serialization
+- Extension type support including timestamps
+
+### Testing Structure
+- **msgpack-core tests**: Written in Scala (always use the latest Scala 3 version) using AirSpec framework
+  - Location: `msgpack-core/src/test/scala/`
+- **msgpack-jackson tests**: Written in Java using JUnit
+  - Location: `msgpack-jackson/src/test/java/`
+
+## Important JVM Options
+
+For JDK 17+ compatibility, these options are automatically added:
+```
+--add-opens=java.base/java.nio=ALL-UNNAMED
+--add-opens=java.base/sun.nio.ch=ALL-UNNAMED
+```
+
+## Code Style Requirements
+- Java code follows Facebook Presto style (enforced by checkstyle)
+- Scala test code uses Scalafmt with Scala 3 dialect and 100 character line limit
+- Checkstyle runs automatically during compilation
+- No external dependencies allowed in msgpack-core
+
+## Key Design Principles
+1. **Zero Dependencies**: msgpack-core has no external dependencies
+2. **Platform Optimization**: Uses platform-specific optimizations when available
+3. **Streaming Support**: Both streaming and object-based APIs
+4. **Type Safety**: Immutable Value hierarchy for type-safe data handling
+5. **Extension Support**: Extensible type system for custom data types
\ No newline at end of file
diff --git a/NOTICE b/NOTICE
index bc6328dba..93b2e28bd 100644
--- a/NOTICE
+++ b/NOTICE
@@ -1,5 +1,5 @@
 This product includes the software developed by third-party:
 
- * Google Guava https://code.google.com/p/guava-libraries/  (APL2)
+ * Google Guava https://code.google.com/p/guava-libraries/  (Apache-2.0)
  * sbt-extras: https://github.com/paulp/sbt-extras  (BSD)  (LICENSE.sbt-extras.txt)
 
diff --git a/README.md b/README.md
index c5af97cdf..f23af0b77 100644
--- a/README.md
+++ b/README.md
@@ -40,14 +40,23 @@ dependencies {
 }
 ```
 
-- [Usage examples](msgpack-core/src/test/java/org/msgpack/core/example/MessagePackExample.java)
+- [Usage examples](https://github.com/msgpack/msgpack-java/blob/develop/msgpack-core/src/test/java/org/msgpack/core/example/MessagePackExample.java)
+
+### Java 17 Support
+
+For using DirectByteBuffer (off-heap memory access methods) in JDK17, you need to specify two JVM options:
+```
+--add-opens=java.base/java.nio=ALL-UNNAMED
+--add-opens=java.base/sun.nio.ch=ALL-UNNAMED
+```
+
 
 ### Integration with Jackson ObjectMapper (jackson-databind)
 
 msgpack-java supports serialization and deserialization of Java objects through [jackson-databind](https://github.com/FasterXML/jackson-databind).
-For details, see [msgpack-jackson/README.md](msgpack-jackson/README.md). The template-based serialization mechanism used in v06 is deprecated.
+For details, see [msgpack-jackson/README.md](https://github.com/msgpack/msgpack-java/blob/develop/msgpack-jackson/README.md). The template-based serialization mechanism used in v06 is deprecated.
 
-- [Release Notes](RELEASE_NOTES.md)
+- [Release Notes](https://github.com/msgpack/msgpack-java/blob/develop/RELEASE_NOTES.md)
 
 ## For MessagePack Developers [![Travis CI](https://travis-ci.org/msgpack/msgpack-java.svg?branch=v07-develop)](https://travis-ci.org/msgpack/msgpack-java)
 
@@ -57,6 +66,7 @@ msgpack-java uses [sbt](http://www.scala-sbt.org/) for building the projects. Fo
 Coding style
  * msgpack-java uses [the same coding style](https://github.com/airlift/codestyle) with Facebook Presto
   * [IntelliJ setting file](https://raw.githubusercontent.com/airlift/codestyle/master/IntelliJIdea14/Airlift.xml)
+ * Scala test code uses Scalafmt with Scala 3 dialect (always use the latest Scala 3 version)
 
 ### Basic sbt commands
 Enter the sbt console:
@@ -67,16 +77,14 @@ $ ./sbt
 Here is a list of sbt commands for daily development:
 ```
 > ~compile                                 # Compile source codes
-> ~test:compile                            # Compile both source and test codes
+> ~"Test / compile"                        # Compile both source and test codes
 > ~test                                    # Run tests upon source code change
 > ~testOnly *MessagePackTest               # Run tests in the specified class
 > ~testOnly *MessagePackTest -- (pattern)  # Run tests matching the pattern 
 > project msgpack-core                     # Focus on a specific project
 > package                                  # Create a jar file in the target folder of each project
-> findbugs                                 # Produce findbugs report in target/findbugs
-> jacoco:cover                             # Report the code coverage of tests to target/jacoco folder
 > jcheckStyle                              # Run check style
-> ;scalafmt;test:scalafmt;scalafmtSbt      # Reformat Scala codes
+> scalafmtAll                              # Format all Scala and sbt code
 ```
 
 ### Publishing
@@ -89,41 +97,49 @@ Here is a list of sbt commands for daily development:
 
 ### Publish to Sonatype (Maven Central)
 
-To publish a new version, you only need to add a new git tag and push it to GitHub. GitHub Action will deploy a new release version to Maven Central (Sonatype).
+To publish a new version, add a new git tag and push it to GitHub. GitHub Action will deploy a new release version to Maven Central (Sonatype).
 
 ```scala
 $ git tag v0.x.y
 $ git push origin v0.x.y
 ```
 
-To generate a release notes, you can use this command line:
-```
-$ git log v(last version).. --oneline | cut -f 2- -d ' ' | perl -npe 's/(.*)\(\#([0-9]+)\)/* \1\[\#\2\]\(https:\/\/round-lake.dustinice.workers.dev:443\/http\/github.com\/msgpack\/msgpack-java\/pull\/\2\)/g'
-```
+A new release note will be generated automatically at the [GitHub Releases](https://github.com/msgpack/msgpack-java/releases) page. 
 
 #### Publishing to Sonatype from Local Machine
 
-If you need to publish to Maven central using a local machine, you need to configure [sbt-sonatype](https://github.com/xerial/sbt-sonatype) plugin. First set Sonatype account information (user name and password) in the global sbt settings. To protect your password, never include this file in your project.
+If you need to publish to Maven central using a local machine, you need to configure credentials for Sonatype Central. First set Sonatype account information (user name and password) in the global sbt settings. To protect your password, never include this file in your project.
 
-___$HOME/.sbt/(sbt-version)/sonatype.sbt___
+___$HOME/.sbt/1.0/credentials.sbt___
 
 ```
-credentials += Credentials("Sonatype Nexus Repository Manager",
-        "oss.sonatype.org",
-        "(Sonatype user name)",
-        "(Sonatype password)")
+credentials += Credentials(Path.userHome / ".sbt" / "sonatype_central_credentials")
+```
+
+Then create a credentials file at `~/.sbt/sonatype_central_credentials`:
+
+```
+host=central.sonatype.com
+user=<your username>
+password=<your password>
+```
+
+Alternatively, you can use environment variables:
+```bash
+export SONATYPE_USERNAME=<your username>
+export SONATYPE_PASSWORD=<your password>
 ```
 
 You may also need to configure GPG. See the instruction in [sbt-pgp](https://github.com/sbt/sbt-pgp).
 
-Then, run `publishedSigned` followed by `sonatypeBundleRelease`:
+Then, run `publishSigned` followed by `sonaRelease`:
 ```
 # [optional] When you need to perform the individual release steps manually, use the following commands:
 > publishSigned           # Publish GPG signed artifacts to the Sonatype repository
-> sonatypeBundleRelease   # Publish to the Maven Central (It will be synched within less than 4 hours)
+> sonaRelease             # Publish to the Maven Central (It will be synched within less than 4 hours)
 ```
 
-If some sporadic error happens (e.g., Sonatype timeout), rerun `sonatypeBundleRelease` again.
+If some sporadic error happens (e.g., Sonatype timeout), rerun `sonaRelease` again.
 
 ### Project Structure
 
diff --git a/RELEASE_NOTES.md b/RELEASE_NOTES.md
index 4f00c472d..3f8d8d9dd 100644
--- a/RELEASE_NOTES.md
+++ b/RELEASE_NOTES.md
@@ -1,5 +1,57 @@
 # Release Notes
 
+The latest release notes will be available from the [GitHub release page](https://github.com/msgpack/msgpack-java/releases)
+
+## 0.9.3
+
+This version supports JDK17 [#660](http://github.com/msgpack/msgpack-java/pull/660).
+
+Important: If you need to use DirectByteBuffer (raw memory access) in JDK17 or later, specify two JVM options to allow accessing
+native memory:
+```
+--add-opens=java.base/java.nio=ALL-UNNAMED
+--add-opens=java.base/sun.nio.ch=ALL-UNNAMED
+```
+Internal updates:
+
+* Use SPDX-ID in license name [#653](http://github.com/msgpack/msgpack-java/pull/653)
+* Update airframe-json, airspec to 22.6.4 [#659](http://github.com/msgpack/msgpack-java/pull/659)
+* Update akka-actor to 2.6.19 [#647](http://github.com/msgpack/msgpack-java/pull/647)
+
+## 0.9.2
+
+Internal updates:
+
+* Update jackson-databind to 2.13.3 [#650](http://github.com/msgpack/msgpack-java/pull/650)
+* Update akka-actor to 2.6.19 [#631](http://github.com/msgpack/msgpack-java/pull/631)
+* Update airframe-json, airspec to 22.6.1 [#649](http://github.com/msgpack/msgpack-java/pull/649)
+* Update scalacheck to 1.16.0 [#636](http://github.com/msgpack/msgpack-java/pull/636)
+* Update scala-collection-compat to 2.7.0 [#632](http://github.com/msgpack/msgpack-java/pull/632)
+* Update sbt-sonatype to 3.9.13 [#644](http://github.com/msgpack/msgpack-java/pull/644)
+* Update airframe-json, airspec to 22.5.0 [#643](http://github.com/msgpack/msgpack-java/pull/643)
+* Update sbt to 1.6.2 [#630](http://github.com/msgpack/msgpack-java/pull/630)
+
+## 0.9.1
+
+Bug fixes and improvements:
+
+- Keep consistent read size after closing MessageUnpacker (#621) @okumin
+- Fixed examples relative link in README (#622) @zbuster05
+- Add an ObjectMapper shorthand @cyberdelia (#620)
+- Specify the bufferSize of the ArrayBufferOutput (#597) @szh
+
+Internal updates:
+
+- Update akka-actor to 2.6.18 (#614) @Scala Steward
+- Update airframe-json, airspec to 22.2.0 (#626) @Scala Steward
+- Update junit-interface to 0.13.3 (#617) @Scala Steward
+- Update sbt-scalafmt to 2.4.6 (#616) @Scala Steward
+- Upgrade sbt to 1.5.6 (#610) @Taro L. Saito
+- Update scala-collection-compat to 2.6.0 (#604) @Scala Steward
+
+Known issues:
+- Unpack method doesn't work in JDK17 https://github.com/msgpack/msgpack-java/issues/600
+
 ## 0.9.0
 
 This version support reading and writing [Timestamp values](https://github.com/msgpack/msgpack/blob/master/spec.md#timestamp-extension-type).
diff --git a/build.sbt b/build.sbt
index b8c4b9d5b..f8600c56f 100644
--- a/build.sbt
+++ b/build.sbt
@@ -1,36 +1,80 @@
 Global / onChangedBuildSource := ReloadOnSourceChanges
 
 // For performance testing, ensure each test run one-by-one
-Global / concurrentRestrictions := Seq(
-  Tags.limit(Tags.Test, 1)
-)
+Global / concurrentRestrictions := Seq(Tags.limit(Tags.Test, 1))
 
-val AIRFRAME_VERSION = "21.12.1"
+val AIRFRAME_VERSION = "2025.1.21"
 
 // Use dynamic snapshot version strings for non tagged versions
 ThisBuild / dynverSonatypeSnapshots := true
 // Use coursier friendly version separator
 ThisBuild / dynverSeparator := "-"
 
-val buildSettings = Seq[Setting[_]](
-  organization := "org.msgpack",
-  organizationName := "MessagePack",
-  organizationHomepage := Some(new URL("http://msgpack.org/")),
-  description := "MessagePack for Java",
-  scalaVersion := "2.13.6",
-  Test / logBuffered := false,
+// Publishing metadata
+ThisBuild / homepage := Some(url("https://msgpack.org/"))
+ThisBuild / licenses := Seq("Apache-2.0" -> url("http://www.apache.org/licenses/LICENSE-2.0.txt"))
+ThisBuild / scmInfo  :=
+  Some(
+    ScmInfo(
+      url("https://github.com/msgpack/msgpack-java"),
+      "scm:git@github.com:msgpack/msgpack-java.git"
+    )
+  )
+
+ThisBuild / developers :=
+  List(
+    Developer(
+      id = "frsyuki",
+      name = "Sadayuki Furuhashi",
+      email = "frsyuki@users.sourceforge.jp",
+      url = url("https://github.com/frsyuki")
+    ),
+    Developer(
+      id = "muga",
+      name = "Muga Nishizawa",
+      email = "muga.nishizawa@gmail.com",
+      url = url("https://github.com/muga")
+    ),
+    Developer(
+      id = "oza",
+      name = "Tsuyoshi Ozawa",
+      email = "ozawa.tsuyoshi@gmail.com",
+      url = url("https://github.com/oza")
+    ),
+    Developer(
+      id = "komamitsu",
+      name = "Mitsunori Komatsu",
+      email = "komamitsu@gmail.com",
+      url = url("https://github.com/komamitsu")
+    ),
+    Developer(
+      id = "xerial",
+      name = "Taro L. Saito",
+      email = "leo@xerial.org",
+      url = url("https://github.com/xerial")
+    )
+  )
+
+val buildSettings = Seq[Setting[?]](
+  organization         := "org.msgpack",
+  organizationName     := "MessagePack",
+  organizationHomepage := Some(url("http://msgpack.org/")),
+  description          := "MessagePack for Java",
+  scalaVersion         := "3.7.1",
+  Test / logBuffered   := false,
   // msgpack-java should be a pure-java library, so remove Scala specific configurations
-  autoScalaLibrary := false,
-  crossPaths := false,
+  autoScalaLibrary  := false,
+  crossPaths        := false,
   publishMavenStyle := true,
   // JVM options for building
   scalacOptions ++= Seq("-encoding", "UTF-8", "-deprecation", "-unchecked", "-feature"),
   Test / javaOptions ++= Seq("-ea"),
-  javacOptions ++= Seq("-source", "1.7", "-target", "1.7"),
-  Compile / compile / javacOptions ++= Seq("-encoding", "UTF-8", "-Xlint:unchecked", "-Xlint:deprecation"),
+  javacOptions ++= Seq("-source", "1.8", "-target", "1.8"),
+  Compile / compile / javacOptions ++=
+    Seq("-encoding", "UTF-8", "-Xlint:unchecked", "-Xlint:deprecation"),
   // Use lenient validation mode when generating Javadoc (for Java8)
   doc / javacOptions := {
-    val opts = Seq("-source", "1.7")
+    val opts = Seq("-source", "1.8")
     if (scala.util.Properties.isJavaAtLeast("1.8")) {
       opts ++ Seq("-Xdoclint:none")
     } else {
@@ -38,15 +82,24 @@ val buildSettings = Seq[Setting[_]](
     }
   },
   // Add sonatype repository settings
-  publishTo := sonatypePublishToBundle.value,
+  publishTo := {
+    val centralSnapshots = "https://central.sonatype.com/repository/maven-snapshots/"
+    if (isSnapshot.value)
+      Some("central-snapshots" at centralSnapshots)
+    else
+      localStaging.value
+  },
   // Style check config: (sbt-jchekcstyle)
   jcheckStyleConfig := "facebook",
   // Run jcheckstyle both for main and test codes
-  Compile / compile := ((Compile / compile) dependsOn (Compile / jcheckStyle)).value,
-  Test / compile := ((Test / compile) dependsOn (Test / jcheckStyle)).value
+  Compile / compile :=
+    ((Compile / compile) dependsOn (Compile / jcheckStyle)).value,
+  Test / compile :=
+    ((Test / compile) dependsOn (Test / jcheckStyle)).value
 )
 
-val junitInterface = "com.github.sbt" % "junit-interface" % "0.13.2" % "test"
+val junitJupiter = "org.junit.jupiter" % "junit-jupiter"        % "5.14.1" % "test"
+val junitVintage = "org.junit.vintage" % "junit-vintage-engine" % "5.11.4" % "test"
 
 // Project settings
 lazy val root = Project(id = "msgpack-java", base = file("."))
@@ -54,8 +107,8 @@ lazy val root = Project(id = "msgpack-java", base = file("."))
     buildSettings,
     // Do not publish the root project
     publishArtifact := false,
-    publish := {},
-    publishLocal := {}
+    publish         := {},
+    publishLocal    := {}
   )
   .aggregate(msgpackCore, msgpackJackson)
 
@@ -63,49 +116,58 @@ lazy val msgpackCore = Project(id = "msgpack-core", base = file("msgpack-core"))
   .enablePlugins(SbtOsgi)
   .settings(
     buildSettings,
-    description := "Core library of the MessagePack for Java",
+    description                 := "Core library of the MessagePack for Java",
     OsgiKeys.bundleSymbolicName := "org.msgpack.msgpack-core",
-    OsgiKeys.exportPackage := Seq(
-      // TODO enumerate used packages automatically
-      "org.msgpack.core",
-      "org.msgpack.core.annotations",
-      "org.msgpack.core.buffer",
-      "org.msgpack.value",
-      "org.msgpack.value.impl"
-    ),
+    OsgiKeys.exportPackage      :=
+      Seq(
+        // TODO enumerate used packages automatically
+        "org.msgpack.core",
+        "org.msgpack.core.annotations",
+        "org.msgpack.core.buffer",
+        "org.msgpack.value",
+        "org.msgpack.value.impl"
+      ),
     testFrameworks += new TestFramework("wvlet.airspec.Framework"),
-    libraryDependencies ++= Seq(
-      // msgpack-core should have no external dependencies
-      junitInterface,
-      "org.wvlet.airframe" %% "airframe-json" % AIRFRAME_VERSION % "test",
-      "org.wvlet.airframe" %% "airspec"       % AIRFRAME_VERSION % "test",
-      // Add property testing support with forAll methods
-      "org.scalacheck" %% "scalacheck" % "1.15.4" % "test",
-      // For performance comparison with msgpack v6
-      "org.msgpack" % "msgpack" % "0.6.12" % "test",
-      // For integration test with Akka
-      "com.typesafe.akka"      %% "akka-actor"              % "2.6.17" % "test",
-      "org.scala-lang.modules" %% "scala-collection-compat" % "2.6.0"  % "test"
-    )
+    Test / javaOptions ++=
+      Seq(
+        // --add-opens is not available in JDK8
+        "-XX:+IgnoreUnrecognizedVMOptions",
+        "--add-opens=java.base/java.nio=ALL-UNNAMED",
+        "--add-opens=java.base/sun.nio.ch=ALL-UNNAMED"
+      ),
+    Test / fork := true,
+    libraryDependencies ++=
+      Seq(
+        // msgpack-core should have no external dependencies
+        junitJupiter,
+        junitVintage,
+        "org.wvlet.airframe" %% "airframe-json" % AIRFRAME_VERSION % "test",
+        "org.wvlet.airframe" %% "airspec"       % AIRFRAME_VERSION % "test",
+        // Add property testing support with forAll methods
+        "org.scalacheck" %% "scalacheck" % "1.19.0" % "test",
+        // For performance comparison with msgpack v6
+        "org.msgpack" % "msgpack" % "0.6.12" % "test",
+        // For integration test with Akka
+        "com.typesafe.akka"      %% "akka-actor"              % "2.6.20" % "test",
+        "org.scala-lang.modules" %% "scala-collection-compat" % "2.14.0" % "test"
+      )
   )
 
-lazy val msgpackJackson =
-  Project(id = "msgpack-jackson", base = file("msgpack-jackson"))
-    .enablePlugins(SbtOsgi)
-    .settings(
-      buildSettings,
-      name := "jackson-dataformat-msgpack",
-      description := "Jackson extension that adds support for MessagePack",
-      OsgiKeys.bundleSymbolicName := "org.msgpack.msgpack-jackson",
-      OsgiKeys.exportPackage := Seq(
-        "org.msgpack.jackson",
-        "org.msgpack.jackson.dataformat"
-      ),
-      libraryDependencies ++= Seq(
-        "com.fasterxml.jackson.core" % "jackson-databind" % "2.10.5.1",
-        junitInterface,
+lazy val msgpackJackson = Project(id = "msgpack-jackson", base = file("msgpack-jackson"))
+  .enablePlugins(SbtOsgi)
+  .settings(
+    buildSettings,
+    name                        := "jackson-dataformat-msgpack",
+    description                 := "Jackson extension that adds support for MessagePack",
+    OsgiKeys.bundleSymbolicName := "org.msgpack.msgpack-jackson",
+    OsgiKeys.exportPackage      := Seq("org.msgpack.jackson", "org.msgpack.jackson.dataformat"),
+    libraryDependencies ++=
+      Seq(
+        "com.fasterxml.jackson.core" % "jackson-databind" % "2.18.4",
+        junitJupiter,
+        junitVintage,
         "org.apache.commons" % "commons-math3" % "3.6.1" % "test"
       ),
-      testOptions += Tests.Argument(TestFrameworks.JUnit, "-v")
-    )
-    .dependsOn(msgpackCore)
+    testOptions += Tests.Argument(TestFrameworks.JUnit, "-v")
+  )
+  .dependsOn(msgpackCore)
diff --git a/msgpack-core/src/main/java/org/msgpack/core/MessagePacker.java b/msgpack-core/src/main/java/org/msgpack/core/MessagePacker.java
index 4cf789d9f..72c26ecac 100644
--- a/msgpack-core/src/main/java/org/msgpack/core/MessagePacker.java
+++ b/msgpack-core/src/main/java/org/msgpack/core/MessagePacker.java
@@ -774,10 +774,6 @@ else if (s.length() < (1 << 16)) {
                     position += written;
                 }
                 else {
-                    if (written >= (1L << 32)) {  // this check does nothing because (1L << 32) is larger than Integer.MAX_VALUE
-                        // this must not happen because s.length() is less than 2^16 and (2^16) * UTF_8_MAX_CHAR_SIZE is less than 2^32
-                        throw new IllegalArgumentException("Unexpected UTF-8 encoder state");
-                    }
                     // move 2 bytes backward to expand 3-byte header region to 5 bytes
                     buffer.putMessageBuffer(position + 5, buffer, position + 3, written);
                     // write 3-byte header header
diff --git a/msgpack-core/src/main/java/org/msgpack/core/MessageUnpacker.java b/msgpack-core/src/main/java/org/msgpack/core/MessageUnpacker.java
index c59b742ac..5a9a1a631 100644
--- a/msgpack-core/src/main/java/org/msgpack/core/MessageUnpacker.java
+++ b/msgpack-core/src/main/java/org/msgpack/core/MessageUnpacker.java
@@ -342,7 +342,7 @@ private static int utf8MultibyteCharacterSize(byte firstByte)
     }
 
     /**
-     * Returns true true if this unpacker has more elements.
+     * Returns true if this unpacker has more elements.
      * When this returns true, subsequent call to {@link #getNextFormat()} returns an
      * MessageFormat instance. If false, next {@link #getNextFormat()} call will throw an MessageInsufficientBufferException.
      *
@@ -624,6 +624,9 @@ public ImmutableValue unpackValue()
                 return ValueFactory.newFloat(unpackDouble());
             case STRING: {
                 int length = unpackRawStringHeader();
+                if (length > stringSizeLimit) {
+                    throw new MessageSizeException(String.format("cannot unpack a String of size larger than %,d: %,d", stringSizeLimit, length), length);
+                }
                 return ValueFactory.newString(readPayload(length), true);
             }
             case BINARY: {
@@ -689,6 +692,9 @@ public Variable unpackValue(Variable var)
                 return var;
             case STRING: {
                 int length = unpackRawStringHeader();
+                if (length > stringSizeLimit) {
+                    throw new MessageSizeException(String.format("cannot unpack a String of size larger than %,d: %,d", stringSizeLimit, length), length);
+                }
                 var.setStringValue(readPayload(length));
                 return var;
             }
@@ -753,7 +759,7 @@ public void unpackNil()
     /**
      * Peeks a Nil byte and reads it if next byte is a nil value.
      *
-     * The difference from {@link unpackNil} is that unpackNil throws an exception if the next byte is not nil value
+     * The difference from {@link #unpackNil()} is that unpackNil throws an exception if the next byte is not nil value
      * while this tryUnpackNil method returns false without changing position.
      *
      * @return true if a nil value is read
@@ -1735,6 +1741,7 @@ private int readNextLength32()
     public void close()
             throws IOException
     {
+        totalReadBytes += position;
         buffer = EMPTY_BUFFER;
         position = 0;
         in.close();
diff --git a/msgpack-core/src/main/java/org/msgpack/core/buffer/DirectBufferAccess.java b/msgpack-core/src/main/java/org/msgpack/core/buffer/DirectBufferAccess.java
index cde2e6eca..7b5ea461d 100644
--- a/msgpack-core/src/main/java/org/msgpack/core/buffer/DirectBufferAccess.java
+++ b/msgpack-core/src/main/java/org/msgpack/core/buffer/DirectBufferAccess.java
@@ -18,11 +18,13 @@
 import java.lang.reflect.Constructor;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
+import java.nio.Buffer;
 import java.nio.ByteBuffer;
 import java.security.AccessController;
 import java.security.PrivilegedAction;
 
 import sun.misc.Unsafe;
+import sun.nio.ch.DirectBuffer;
 
 /**
  * Wraps the difference of access methods to DirectBuffers between Android and others.
@@ -30,17 +32,18 @@
 class DirectBufferAccess
 {
     private DirectBufferAccess()
-    {}
+    {
+    }
 
     enum DirectBufferConstructorType
     {
+        ARGS_LONG_LONG,
         ARGS_LONG_INT_REF,
         ARGS_LONG_INT,
         ARGS_INT_INT,
         ARGS_MB_INT_INT
     }
 
-    static Method mGetAddress;
     // For Java <=8, gets a sun.misc.Cleaner
     static Method mCleaner;
     static Method mClean;
@@ -62,28 +65,35 @@ enum DirectBufferConstructorType
             DirectBufferConstructorType constructorType = null;
             Method mbWrap = null;
             try {
-                // TODO We should use MethodHandle for Java7, which can avoid the cost of boxing with JIT optimization
-                directByteBufferConstructor = directByteBufferClass.getDeclaredConstructor(long.class, int.class, Object.class);
-                constructorType = DirectBufferConstructorType.ARGS_LONG_INT_REF;
+                // JDK21 DirectByteBuffer(long, long)
+                directByteBufferConstructor = directByteBufferClass.getDeclaredConstructor(long.class, long.class);
+                constructorType = DirectBufferConstructorType.ARGS_LONG_LONG;
             }
-            catch (NoSuchMethodException e0) {
+            catch (NoSuchMethodException e00) {
                 try {
-                    // https://android.googlesource.com/platform/libcore/+/master/luni/src/main/java/java/nio/DirectByteBuffer.java
-                    // DirectByteBuffer(long address, int capacity)
-                    directByteBufferConstructor = directByteBufferClass.getDeclaredConstructor(long.class, int.class);
-                    constructorType = DirectBufferConstructorType.ARGS_LONG_INT;
+                    // TODO We should use MethodHandle for Java7, which can avoid the cost of boxing with JIT optimization
+                    directByteBufferConstructor = directByteBufferClass.getDeclaredConstructor(long.class, int.class, Object.class);
+                    constructorType = DirectBufferConstructorType.ARGS_LONG_INT_REF;
                 }
-                catch (NoSuchMethodException e1) {
+                catch (NoSuchMethodException e0) {
                     try {
-                        directByteBufferConstructor = directByteBufferClass.getDeclaredConstructor(int.class, int.class);
-                        constructorType = DirectBufferConstructorType.ARGS_INT_INT;
+                        // https://android.googlesource.com/platform/libcore/+/master/luni/src/main/java/java/nio/DirectByteBuffer.java
+                        // DirectByteBuffer(long address, int capacity)
+                        directByteBufferConstructor = directByteBufferClass.getDeclaredConstructor(long.class, int.class);
+                        constructorType = DirectBufferConstructorType.ARGS_LONG_INT;
                     }
-                    catch (NoSuchMethodException e2) {
-                        Class<?> aClass = Class.forName("java.nio.MemoryBlock");
-                        mbWrap = aClass.getDeclaredMethod("wrapFromJni", int.class, long.class);
-                        mbWrap.setAccessible(true);
-                        directByteBufferConstructor = directByteBufferClass.getDeclaredConstructor(aClass, int.class, int.class);
-                        constructorType = DirectBufferConstructorType.ARGS_MB_INT_INT;
+                    catch (NoSuchMethodException e1) {
+                        try {
+                            directByteBufferConstructor = directByteBufferClass.getDeclaredConstructor(int.class, int.class);
+                            constructorType = DirectBufferConstructorType.ARGS_INT_INT;
+                        }
+                        catch (NoSuchMethodException e2) {
+                            Class<?> aClass = Class.forName("java.nio.MemoryBlock");
+                            mbWrap = aClass.getDeclaredMethod("wrapFromJni", int.class, long.class);
+                            mbWrap.setAccessible(true);
+                            directByteBufferConstructor = directByteBufferClass.getDeclaredConstructor(aClass, int.class, int.class);
+                            constructorType = DirectBufferConstructorType.ARGS_MB_INT_INT;
+                        }
                     }
                 }
             }
@@ -95,10 +105,19 @@ enum DirectBufferConstructorType
             if (byteBufferConstructor == null) {
                 throw new RuntimeException("Constructor of DirectByteBuffer is not found");
             }
-            byteBufferConstructor.setAccessible(true);
 
-            mGetAddress = directByteBufferClass.getDeclaredMethod("address");
-            mGetAddress.setAccessible(true);
+            try {
+                byteBufferConstructor.setAccessible(true);
+            }
+            catch (RuntimeException e) {
+                // This is a Java9+ exception, so we need to detect it without importing it for Java8 support
+                if ("java.lang.reflect.InaccessibleObjectException".equals(e.getClass().getName())) {
+                    byteBufferConstructor = null;
+                }
+                else {
+                    throw e;
+                }
+            }
 
             if (MessageBuffer.javaVersion <= 8) {
                 setupCleanerJava6(direct);
@@ -160,6 +179,7 @@ public Object run()
 
     /**
      * Checks if we have a usable {@link DirectByteBuffer#cleaner}.
+     *
      * @param direct a direct buffer
      * @return the method or an error
      */
@@ -184,6 +204,7 @@ private static Object getCleanerMethod(ByteBuffer direct)
 
     /**
      * Checks if we have a usable {@link sun.misc.Cleaner#clean}.
+     *
      * @param direct a direct buffer
      * @param mCleaner the {@link DirectByteBuffer#cleaner} method
      * @return the method or null
@@ -210,6 +231,7 @@ private static Object getCleanMethod(ByteBuffer direct, Method mCleaner)
 
     /**
      * Checks if we have a usable {@link Unsafe#invokeCleaner}.
+     *
      * @param direct a direct buffer
      * @return the method or an error
      */
@@ -218,7 +240,7 @@ private static Object getInvokeCleanerMethod(ByteBuffer direct)
         try {
             // See https://bugs.openjdk.java.net/browse/JDK-8171377
             Method m = MessageBuffer.unsafe.getClass().getDeclaredMethod(
-                "invokeCleaner", ByteBuffer.class);
+                    "invokeCleaner", ByteBuffer.class);
             m.invoke(MessageBuffer.unsafe, direct);
             return m;
         }
@@ -233,17 +255,9 @@ private static Object getInvokeCleanerMethod(ByteBuffer direct)
         }
     }
 
-    static long getAddress(Object base)
+    static long getAddress(Buffer buffer)
     {
-        try {
-            return (Long) mGetAddress.invoke(base);
-        }
-        catch (IllegalAccessException e) {
-            throw new RuntimeException(e);
-        }
-        catch (InvocationTargetException e) {
-            throw new RuntimeException(e);
-        }
+        return ((DirectBuffer) buffer).address();
     }
 
     static void clean(Object base)
@@ -253,7 +267,7 @@ static void clean(Object base)
                 Object cleaner = mCleaner.invoke(base);
                 mClean.invoke(cleaner);
             }
-        else {
+            else {
                 mInvokeCleaner.invoke(MessageBuffer.unsafe, base);
             }
         }
@@ -269,8 +283,14 @@ static boolean isDirectByteBufferInstance(Object s)
 
     static ByteBuffer newByteBuffer(long address, int index, int length, ByteBuffer reference)
     {
+        if (byteBufferConstructor == null) {
+            throw new IllegalStateException("Can't create a new DirectByteBuffer. In JDK17+, two JVM options needs to be set: " +
+                    "--add-opens=java.base/java.nio=ALL-UNNAMED and --add-opens=java.base/sun.nio.ch=ALL-UNNAMED");
+        }
         try {
             switch (directBufferConstructorType) {
+                case ARGS_LONG_LONG:
+                    return (ByteBuffer) byteBufferConstructor.newInstance(address + index, (long) length);
                 case ARGS_LONG_INT_REF:
                     return (ByteBuffer) byteBufferConstructor.newInstance(address + index, length, reference);
                 case ARGS_LONG_INT:
diff --git a/msgpack-core/src/main/java/org/msgpack/value/Variable.java b/msgpack-core/src/main/java/org/msgpack/value/Variable.java
index ae88170c7..85d2fb3b0 100644
--- a/msgpack-core/src/main/java/org/msgpack/value/Variable.java
+++ b/msgpack-core/src/main/java/org/msgpack/value/Variable.java
@@ -817,7 +817,7 @@ public Variable setArrayValue(List<Value> v)
     {
         this.type = Type.LIST;
         this.accessor = arrayAccessor;
-        this.objectValue = v.toArray();
+        this.objectValue = v.toArray(new Value[v.size()]);
         return this;
     }
 
diff --git a/msgpack-core/src/main/java/org/msgpack/value/impl/ImmutableTimestampValueImpl.java b/msgpack-core/src/main/java/org/msgpack/value/impl/ImmutableTimestampValueImpl.java
index 227c85d0b..1891d9a7f 100644
--- a/msgpack-core/src/main/java/org/msgpack/value/impl/ImmutableTimestampValueImpl.java
+++ b/msgpack-core/src/main/java/org/msgpack/value/impl/ImmutableTimestampValueImpl.java
@@ -93,7 +93,7 @@ public byte[] getData()
             long sec = getEpochSecond();
             int nsec = getNano();
             if (sec >>> 34 == 0) {
-                long data64 = (nsec << 34) | sec;
+                long data64 = ((long) nsec << 34) | sec;
                 if ((data64 & 0xffffffff00000000L) == 0L) {
                     bytes = new byte[4];
                     MessageBuffer.wrap(bytes).putInt(0, (int) sec);
diff --git a/msgpack-core/src/test/scala/org/msgpack/core/InvalidDataReadTest.scala b/msgpack-core/src/test/scala/org/msgpack/core/InvalidDataReadTest.scala
index 6f0138385..76f04c97d 100644
--- a/msgpack-core/src/test/scala/org/msgpack/core/InvalidDataReadTest.scala
+++ b/msgpack-core/src/test/scala/org/msgpack/core/InvalidDataReadTest.scala
@@ -5,20 +5,19 @@ import wvlet.airspec.AirSpec
 
 /**
   */
-class InvalidDataReadTest extends AirSpec {
+class InvalidDataReadTest extends AirSpec:
 
   test("Reading long EXT32") {
     // Prepare an EXT32 data with 2GB (Int.MaxValue size) payload for testing the behavior of MessageUnpacker.skipValue()
     // Actually preparing 2GB of data, however, is too much for CI, so we create only the header part.
-    val msgpack = createMessagePackData(p => p.packExtensionTypeHeader(MessagePack.Code.EXT32, Int.MaxValue))
-    val u       = MessagePack.newDefaultUnpacker(msgpack)
-    try {
+    val msgpack = createMessagePackData(p =>
+      p.packExtensionTypeHeader(MessagePack.Code.EXT32, Int.MaxValue)
+    )
+    val u = MessagePack.newDefaultUnpacker(msgpack)
+    try
       // This error will be thrown after reading the header as the input has no EXT32 body
       intercept[MessageInsufficientBufferException] {
         u.skipValue()
       }
-    } finally {
-      u.close()
-    }
+    finally u.close()
   }
-}
diff --git a/msgpack-core/src/test/scala/org/msgpack/core/MessageBufferPackerTest.scala b/msgpack-core/src/test/scala/org/msgpack/core/MessageBufferPackerTest.scala
index 58b29f435..f4b74986c 100644
--- a/msgpack-core/src/test/scala/org/msgpack/core/MessageBufferPackerTest.scala
+++ b/msgpack-core/src/test/scala/org/msgpack/core/MessageBufferPackerTest.scala
@@ -17,10 +17,10 @@ package org.msgpack.core
 
 import java.io.ByteArrayOutputStream
 import java.util.Arrays
-import org.msgpack.value.ValueFactory._
+import org.msgpack.value.ValueFactory.*
 import wvlet.airspec.AirSpec
 
-class MessageBufferPackerTest extends AirSpec {
+class MessageBufferPackerTest extends AirSpec:
   test("MessageBufferPacker") {
     test("be equivalent to ByteArrayOutputStream") {
       val packer1 = MessagePack.newDefaultBufferPacker
@@ -48,4 +48,3 @@ class MessageBufferPackerTest extends AirSpec {
     }
 
   }
-}
diff --git a/msgpack-core/src/test/scala/org/msgpack/core/MessageFormatTest.scala b/msgpack-core/src/test/scala/org/msgpack/core/MessageFormatTest.scala
index 06a58e112..a626978d5 100644
--- a/msgpack-core/src/test/scala/org/msgpack/core/MessageFormatTest.scala
+++ b/msgpack-core/src/test/scala/org/msgpack/core/MessageFormatTest.scala
@@ -25,46 +25,38 @@ import scala.util.Random
 /**
   * Created on 2014/05/07.
   */
-class MessageFormatTest extends AirSpec with Benchmark {
+class MessageFormatTest extends AirSpec with Benchmark:
   test("MessageFormat") {
     test("cover all byte codes") {
-      def checkV(b: Byte, tpe: ValueType): Unit = {
-        try MessageFormat.valueOf(b).getValueType shouldBe tpe
-        catch {
+      def checkV(b: Byte, tpe: ValueType): Unit =
+        try
+          MessageFormat.valueOf(b).getValueType shouldBe tpe
+        catch
           case e: AirSpecException =>
             error(f"Failure when looking at byte ${b}%02x")
             throw e
-        }
-      }
 
-      def checkF(b: Byte, f: MessageFormat): Unit = {
-        MessageFormat.valueOf(b) shouldBe f
-      }
+      def checkF(b: Byte, f: MessageFormat): Unit = MessageFormat.valueOf(b) shouldBe f
 
-      def check(b: Byte, tpe: ValueType, f: MessageFormat): Unit = {
+      def check(b: Byte, tpe: ValueType, f: MessageFormat): Unit =
         checkV(b, tpe)
         checkF(b, f)
-      }
 
-      for (i <- 0 until 0x7f) {
+      for i <- 0 until 0x7f do
         check(i.toByte, ValueType.INTEGER, MessageFormat.POSFIXINT)
-      }
 
-      for (i <- 0x80 until 0x8f) {
+      for i <- 0x80 until 0x8f do
         check(i.toByte, ValueType.MAP, MessageFormat.FIXMAP)
-      }
 
-      for (i <- 0x90 until 0x9f) {
+      for i <- 0x90 until 0x9f do
         check(i.toByte, ValueType.ARRAY, MessageFormat.FIXARRAY)
-      }
 
       check(Code.NIL, ValueType.NIL, MessageFormat.NIL)
 
       MessageFormat.valueOf(Code.NEVER_USED) shouldBe MessageFormat.NEVER_USED
 
-      for (i <- Seq(Code.TRUE, Code.FALSE)) {
+      for i <- Seq(Code.TRUE, Code.FALSE) do
         check(i, ValueType.BOOLEAN, MessageFormat.BOOLEAN)
-      }
 
       check(Code.BIN8, ValueType.BINARY, MessageFormat.BIN8)
       check(Code.BIN16, ValueType.BINARY, MessageFormat.BIN16)
@@ -98,9 +90,8 @@ class MessageFormatTest extends AirSpec with Benchmark {
       check(Code.ARRAY16, ValueType.ARRAY, MessageFormat.ARRAY16)
       check(Code.ARRAY32, ValueType.ARRAY, MessageFormat.ARRAY32)
 
-      for (i <- 0xe0 to 0xff) {
+      for i <- 0xe0 to 0xff do
         check(i.toByte, ValueType.INTEGER, MessageFormat.NEGFIXINT)
-      }
     }
 
     test("improve the valueOf performance") {
@@ -113,20 +104,19 @@ class MessageFormatTest extends AirSpec with Benchmark {
       time("lookup", repeat = 10) {
         block("switch") {
           var i = 0
-          while (i < N) {
+          while i < N do
             MessageFormat.toMessageFormat(idx(i))
             i += 1
-          }
         }
 
         block("table") {
           var i = 0
-          while (i < N) {
+          while i < N do
             MessageFormat.valueOf(idx(i))
             i += 1
-          }
         }
       }
     }
   }
-}
+
+end MessageFormatTest
diff --git a/msgpack-core/src/test/scala/org/msgpack/core/MessagePackSpec.scala b/msgpack-core/src/test/scala/org/msgpack/core/MessagePackSpec.scala
index dee315cd9..135c49216 100644
--- a/msgpack-core/src/test/scala/org/msgpack/core/MessagePackSpec.scala
+++ b/msgpack-core/src/test/scala/org/msgpack/core/MessagePackSpec.scala
@@ -20,31 +20,29 @@ import wvlet.log.io.{TimeReport, Timer}
 
 import java.io.ByteArrayOutputStream
 
-object MessagePackSpec {
+object MessagePackSpec:
   def toHex(arr: Array[Byte]) = arr.map(x => f"$x%02x").mkString(" ")
-  def createMessagePackData(f: MessagePacker => Unit): Array[Byte] = {
+  def createMessagePackData(f: MessagePacker => Unit): Array[Byte] =
     val b      = new ByteArrayOutputStream()
     val packer = MessagePack.newDefaultPacker(b)
     f(packer)
     packer.close()
     b.toByteArray
-  }
-}
 
-trait Benchmark extends Timer {
+trait Benchmark extends Timer:
   private val numWarmUpRuns = 10
 
-  override protected def time[A](blockName: String, logLevel: LogLevel = LogLevel.INFO, repeat: Int = 1, blockRepeat: Int = 1)(f: => A): TimeReport = {
-    super.time(blockName, logLevel = LogLevel.INFO, repeat)(f)
-  }
+  override protected def time[A](
+      blockName: String,
+      logLevel: LogLevel = LogLevel.INFO,
+      repeat: Int = 1,
+      blockRepeat: Int = 1
+  )(f: => A): TimeReport = super.time(blockName, logLevel = LogLevel.INFO, repeat)(f)
 
-  override protected def block[A](name: String)(f: => A): TimeReport = {
+  override protected def block[A](name: String)(f: => A): TimeReport =
     var i = 0
-    while (i < numWarmUpRuns) {
+    while i < numWarmUpRuns do
       f
       i += 1
-    }
 
     super.block(name)(f)
-  }
-}
diff --git a/msgpack-core/src/test/scala/org/msgpack/core/MessagePackTest.scala b/msgpack-core/src/test/scala/org/msgpack/core/MessagePackTest.scala
index 4f6949bd3..b55413934 100644
--- a/msgpack-core/src/test/scala/org/msgpack/core/MessagePackTest.scala
+++ b/msgpack-core/src/test/scala/org/msgpack/core/MessagePackTest.scala
@@ -33,25 +33,23 @@ import scala.util.Random
 /**
   * Created on 2014/05/07.
   */
-class MessagePackTest extends AirSpec with PropertyCheck with Benchmark {
+class MessagePackTest extends AirSpec with PropertyCheck with Benchmark:
 
-  private def isValidUTF8(s: String) = {
-    MessagePack.UTF8.newEncoder().canEncode(s)
-  }
+  private def isValidUTF8(s: String) = MessagePack.UTF8.newEncoder().canEncode(s)
 
-  private def containsUnmappableCharacter(s: String): Boolean = {
-    try {
-      MessagePack.UTF8
+  private def containsUnmappableCharacter(s: String): Boolean =
+    try
+      MessagePack
+        .UTF8
         .newEncoder()
         .onUnmappableCharacter(CodingErrorAction.REPORT)
         .encode(CharBuffer.wrap(s))
       false
-    } catch {
+    catch
       case e: UnmappableCharacterException =>
         true
-      case _: Exception => false
-    }
-  }
+      case _: Exception =>
+        false
 
   test("clone packer config") {
     val config = new PackerConfig()
@@ -78,13 +76,11 @@ class MessagePackTest extends AirSpec with PropertyCheck with Benchmark {
 
   test("detect fixint values") {
 
-    for (i <- 0 until 0x79) {
+    for i <- 0 until 0x7f do
       Code.isPosFixInt(i.toByte) shouldBe true
-    }
 
-    for (i <- 0x80 until 0xff) {
+    for i <- 0x80 until 0xff do
       Code.isPosFixInt(i.toByte) shouldBe false
-    }
   }
 
   test("detect fixarray values") {
@@ -93,12 +89,11 @@ class MessagePackTest extends AirSpec with PropertyCheck with Benchmark {
     packer.close
     val bytes = packer.toByteArray
     MessagePack.newDefaultUnpacker(bytes).unpackArrayHeader() shouldBe 0
-    try {
+    try
       MessagePack.newDefaultUnpacker(bytes).unpackMapHeader()
       fail("Shouldn't reach here")
-    } catch {
+    catch
       case e: MessageTypeException => // OK
-    }
   }
 
   test("detect fixmap values") {
@@ -107,12 +102,11 @@ class MessagePackTest extends AirSpec with PropertyCheck with Benchmark {
     packer.close
     val bytes = packer.toByteArray
     MessagePack.newDefaultUnpacker(bytes).unpackMapHeader() shouldBe 0
-    try {
+    try
       MessagePack.newDefaultUnpacker(bytes).unpackArrayHeader()
       fail("Shouldn't reach here")
-    } catch {
+    catch
       case e: MessageTypeException => // OK
-    }
   }
 
   test("detect fixint quickly") {
@@ -125,34 +119,28 @@ class MessagePackTest extends AirSpec with PropertyCheck with Benchmark {
       block("mask") {
         var i     = 0
         var count = 0
-        while (i < N) {
-          if ((idx(i) & Code.POSFIXINT_MASK) == 0) {
+        while i < N do
+          if (idx(i) & Code.POSFIXINT_MASK) == 0 then
             count += 1
-          }
           i += 1
-        }
       }
 
       block("mask in func") {
         var i     = 0
         var count = 0
-        while (i < N) {
-          if (Code.isPosFixInt(idx(i))) {
+        while i < N do
+          if Code.isPosFixInt(idx(i)) then
             count += 1
-          }
           i += 1
-        }
       }
 
       block("shift cmp") {
         var i     = 0
         var count = 0
-        while (i < N) {
-          if ((idx(i) >>> 7) == 0) {
+        while i < N do
+          if (idx(i) >>> 7) == 0 then
             count += 1
-          }
           i += 1
-        }
 
       }
 
@@ -162,13 +150,11 @@ class MessagePackTest extends AirSpec with PropertyCheck with Benchmark {
 
   test("detect neg fix int values") {
 
-    for (i <- 0 until 0xe0) {
+    for i <- 0 until 0xe0 do
       Code.isNegFixInt(i.toByte) shouldBe false
-    }
 
-    for (i <- 0xe0 until 0xff) {
+    for i <- 0xe0 until 0xff do
       Code.isNegFixInt(i.toByte) shouldBe true
-    }
 
   }
 
@@ -178,9 +164,9 @@ class MessagePackTest extends AirSpec with PropertyCheck with Benchmark {
       unpack: MessageUnpacker => A,
       packerConfig: PackerConfig = new PackerConfig(),
       unpackerConfig: UnpackerConfig = new UnpackerConfig()
-  ): Boolean = {
+  ): Boolean =
     var b: Array[Byte] = null
-    try {
+    try
       val bs     = new ByteArrayOutputStream()
       val packer = packerConfig.newPacker(bs)
       pack(packer)
@@ -192,15 +178,12 @@ class MessagePackTest extends AirSpec with PropertyCheck with Benchmark {
       val ret      = unpack(unpacker)
       ret shouldBe v
       true
-    } catch {
+    catch
       case e: Exception =>
         warn(e.getMessage)
-        if (b != null) {
+        if b != null then
           warn(s"packed data (size:${b.length}): ${toHex(b)}")
-        }
         throw e
-    }
-  }
 
   private def checkException[A](
       v: A,
@@ -208,7 +191,7 @@ class MessagePackTest extends AirSpec with PropertyCheck with Benchmark {
       unpack: MessageUnpacker => A,
       packerConfig: PackerConfig = new PackerConfig(),
       unpaackerConfig: UnpackerConfig = new UnpackerConfig()
-  ): Unit = {
+  ): Unit =
     var b: Array[Byte] = null
     val bs             = new ByteArrayOutputStream()
     val packer         = packerConfig.newPacker(bs)
@@ -221,15 +204,16 @@ class MessagePackTest extends AirSpec with PropertyCheck with Benchmark {
     val ret      = unpack(unpacker)
 
     fail("cannot not reach here")
-  }
 
-  private def checkOverflow[A](v: A, pack: MessagePacker => Unit, unpack: MessageUnpacker => A): Unit = {
-    try {
+  private def checkOverflow[A](
+      v: A,
+      pack: MessagePacker => Unit,
+      unpack: MessageUnpacker => A
+  ): Unit =
+    try
       checkException[A](v, pack, unpack)
-    } catch {
+    catch
       case e: MessageIntegerOverflowException => // OK
-    }
-  }
 
   test("pack/unpack primitive values") {
     forAll { (v: Boolean) =>
@@ -257,7 +241,8 @@ class MessagePackTest extends AirSpec with PropertyCheck with Benchmark {
       null,
       _.packNil,
       { unpacker =>
-        unpacker.unpackNil(); null
+        unpacker.unpackNil();
+        null
       }
     )
   }
@@ -279,29 +264,35 @@ class MessagePackTest extends AirSpec with PropertyCheck with Benchmark {
         packer.packString("val")
       },
       { unpacker =>
-        unpacker.tryUnpackNil(); unpacker.unpackString()
+        unpacker.tryUnpackNil();
+        unpacker.unpackString()
       }
     )
     check(
       "val",
       { packer =>
-        packer.packNil(); packer.packString("val")
+        packer.packNil();
+        packer.packString("val")
       },
       { unpacker =>
-        unpacker.tryUnpackNil(); unpacker.unpackString()
+        unpacker.tryUnpackNil();
+        unpacker.unpackString()
       }
     )
-    try {
-      checkException(null, { _ => }, _.tryUnpackNil)
-    } catch {
+    try
+      checkException(
+        null,
+        { _ =>
+        },
+        _.tryUnpackNil
+      )
+    catch
       case e: MessageInsufficientBufferException => // OK
-    }
   }
 
   test("pack/unpack integer values") {
     val sampleData = Seq[Long](
-      Int.MinValue.toLong -
-        10,
+      Int.MinValue.toLong - 10,
       -65535,
       -8191,
       -1024,
@@ -327,31 +318,26 @@ class MessagePackTest extends AirSpec with PropertyCheck with Benchmark {
       65536,
       Int.MaxValue.toLong + 10
     )
-    for (v <- sampleData) {
+    for v <- sampleData do
       check(v, _.packLong(v), _.unpackLong)
 
-      if (v.isValidInt) {
+      if v.isValidInt then
         val vi = v.toInt
         check(vi, _.packInt(vi), _.unpackInt)
-      } else {
+      else
         checkOverflow(v, _.packLong(v), _.unpackInt)
-      }
 
-      if (v.isValidShort) {
+      if v.isValidShort then
         val vi = v.toShort
         check(vi, _.packShort(vi), _.unpackShort)
-      } else {
+      else
         checkOverflow(v, _.packLong(v), _.unpackShort)
-      }
 
-      if (v.isValidByte) {
+      if v.isValidByte then
         val vi = v.toByte
         check(vi, _.packByte(vi), _.unpackByte)
-      } else {
+      else
         checkOverflow(v, _.packLong(v), _.unpackByte)
-      }
-
-    }
 
   }
 
@@ -361,23 +347,19 @@ class MessagePackTest extends AirSpec with PropertyCheck with Benchmark {
       check(v, _.packBigInteger(v), _.unpackBigInteger)
     }
 
-    for (bi <- Seq(BigInteger.valueOf(Long.MaxValue).add(BigInteger.valueOf(1)))) {
+    for bi <- Seq(BigInteger.valueOf(Long.MaxValue).add(BigInteger.valueOf(1))) do
       check(bi, _.packBigInteger(bi), _.unpackBigInteger())
-    }
 
-    for (bi <- Seq(BigInteger.valueOf(Long.MaxValue).shiftLeft(10))) {
-      try {
+    for bi <- Seq(BigInteger.valueOf(Long.MaxValue).shiftLeft(10)) do
+      try
         checkException(bi, _.packBigInteger(bi), _.unpackBigInteger())
         fail("cannot reach here")
-      } catch {
+      catch
         case e: IllegalArgumentException => // OK
-      }
-    }
-
   }
 
   test("pack/unpack strings") {
-    val utf8Strings = Arbitrary.arbitrary[String].suchThat(isValidUTF8 _)
+    val utf8Strings = Arbitrary.arbitrary[String].suchThat(isValidUTF8)
     utf8Strings.map { v =>
       check(v, _.packString(v), _.unpackString)
     }
@@ -386,17 +368,15 @@ class MessagePackTest extends AirSpec with PropertyCheck with Benchmark {
   test("pack/unpack large strings") {
     // Large string
     val strLen = Seq(1000, 2000, 10000, 50000, 100000, 500000)
-    for (l <- strLen) {
-      val v: String =
-        Iterator.continually(Random.nextString(l * 10)).find(isValidUTF8).get
+    for l <- strLen do
+      val v: String = Iterator.continually(Random.nextString(l * 10)).find(isValidUTF8).get
       check(v, _.packString(v), _.unpackString)
-    }
   }
 
   test("report errors when packing/unpacking malformed strings") {
     pending("We need to produce malformed utf-8 strings in Java 8")
     // Create 100 malformed UTF8 Strings
-    val r = new Random(0)
+    val r                = new Random(0)
     val malformedStrings = Iterator
       .continually {
         val b = new Array[Byte](10)
@@ -406,16 +386,14 @@ class MessagePackTest extends AirSpec with PropertyCheck with Benchmark {
       .filter(b => !isValidUTF8(new String(b)))
       .take(100)
 
-    for (malformedBytes <- malformedStrings) {
+    for malformedBytes <- malformedStrings do
       // Pack tests
       val malformed = new String(malformedBytes)
-      try {
+      try
         checkException(malformed, _.packString(malformed), _.unpackString())
-      } catch {
+      catch
         case e: MessageStringCodingException => // OK
-      }
-
-      try {
+      try
         checkException(
           malformed,
           { packer =>
@@ -424,24 +402,22 @@ class MessagePackTest extends AirSpec with PropertyCheck with Benchmark {
           },
           _.unpackString()
         )
-      } catch {
+      catch
         case e: MessageStringCodingException => // OK
-      }
-    }
   }
 
   test("report errors when packing/unpacking strings that contain unmappable characters") {
 
     val unmappable = Array[Byte](0xfc.toByte, 0x0a.toByte)
-    //val unmappableChar = Array[Char](new Character(0xfc0a).toChar)
+    // val unmappableChar = Array[Char](new Character(0xfc0a).toChar)
 
     // Report error on unmappable character
     val unpackerConfig = new UnpackerConfig()
       .withActionOnMalformedString(CodingErrorAction.REPORT)
       .withActionOnUnmappableString(CodingErrorAction.REPORT)
 
-    for (bytes <- Seq(unmappable)) {
-      try {
+    for bytes <- Seq(unmappable) do
+      try
         checkException(
           bytes,
           { packer =>
@@ -452,10 +428,8 @@ class MessagePackTest extends AirSpec with PropertyCheck with Benchmark {
           new PackerConfig(),
           unpackerConfig
         )
-      } catch {
+      catch
         case e: MessageStringCodingException => // OK
-      }
-    }
   }
 
   test("pack/unpack binary") {
@@ -463,7 +437,8 @@ class MessagePackTest extends AirSpec with PropertyCheck with Benchmark {
       check(
         v,
         { packer =>
-          packer.packBinaryHeader(v.length); packer.writePayload(v)
+          packer.packBinaryHeader(v.length);
+          packer.writePayload(v)
         },
         { unpacker =>
           val len = unpacker.unpackBinaryHeader()
@@ -475,13 +450,14 @@ class MessagePackTest extends AirSpec with PropertyCheck with Benchmark {
     }
 
     val len = Seq(1000, 2000, 10000, 50000, 100000, 500000)
-    for (l <- len) {
+    for l <- len do
       val v = new Array[Byte](l)
       Random.nextBytes(v)
       check(
         v,
         { packer =>
-          packer.packBinaryHeader(v.length); packer.writePayload(v)
+          packer.packBinaryHeader(v.length);
+          packer.writePayload(v)
         },
         { unpacker =>
           val len = unpacker.unpackBinaryHeader()
@@ -490,10 +466,11 @@ class MessagePackTest extends AirSpec with PropertyCheck with Benchmark {
           out
         }
       )
-    }
   }
 
-  val testHeaderLength = Seq(1, 2, 4, 8, 16, 17, 32, 64, 255, 256, 1000, 2000, 10000, 50000, 100000, 500000)
+  val testHeaderLength = Seq(
+    1, 2, 4, 8, 16, 17, 32, 64, 255, 256, 1000, 2000, 10000, 50000, 100000, 500000
+  )
 
   test("pack/unpack arrays") {
     forAll { (v: Array[Int]) =>
@@ -506,24 +483,20 @@ class MessagePackTest extends AirSpec with PropertyCheck with Benchmark {
         { unpacker =>
           val len = unpacker.unpackArrayHeader()
           val out = new Array[Int](len)
-          for (i <- 0 until v.length) {
+          for i <- 0 until v.length do
             out(i) = unpacker.unpackInt
-          }
           out
         }
       )
     }
 
-    for (l <- testHeaderLength) {
+    for l <- testHeaderLength do
       check(l, _.packArrayHeader(l), _.unpackArrayHeader())
-    }
 
-    try {
+    try
       checkException(0, _.packArrayHeader(-1), _.unpackArrayHeader)
-    } catch {
+    catch
       case e: IllegalArgumentException => // OK
-    }
-
   }
 
   test("pack/unpack maps") {
@@ -534,49 +507,51 @@ class MessagePackTest extends AirSpec with PropertyCheck with Benchmark {
         m,
         { packer =>
           packer.packMapHeader(v.length)
-          m.map {
-            case (k: Int, v: String) =>
-              packer.packInt(k)
-              packer.packString(v)
+          m.map { case (k: Int, v: String) =>
+            packer.packInt(k)
+            packer.packString(v)
           }
         },
         { unpacker =>
           val len = unpacker.unpackMapHeader()
           val b   = Seq.newBuilder[(Int, String)]
-          for (i <- 0 until len) {
+          for i <- 0 until len do
             b += ((unpacker.unpackInt, unpacker.unpackString))
-          }
           b.result()
         }
       )
     }
 
-    for (l <- testHeaderLength) {
+    for l <- testHeaderLength do
       check(l, _.packMapHeader(l), _.unpackMapHeader())
-    }
 
-    try {
+    try
       checkException(0, _.packMapHeader(-1), _.unpackMapHeader)
-    } catch {
+    catch
       case e: IllegalArgumentException => // OK
-    }
-
   }
 
   test("pack/unpack extension types") {
     forAll { (dataLen: Int, tpe: Byte) =>
       val l = Math.abs(dataLen)
       l >= 0 ==> {
-        val ext =
-          new ExtensionTypeHeader(ExtensionTypeHeader.checkedCastToByte(tpe), l)
-        check(ext, _.packExtensionTypeHeader(ext.getType, ext.getLength), _.unpackExtensionTypeHeader())
+        val ext = new ExtensionTypeHeader(ExtensionTypeHeader.checkedCastToByte(tpe), l)
+        check(
+          ext,
+          _.packExtensionTypeHeader(ext.getType, ext.getLength),
+          _.unpackExtensionTypeHeader()
+        )
       }
     }
 
-    for (l <- testHeaderLength) {
-      val ext = new ExtensionTypeHeader(ExtensionTypeHeader.checkedCastToByte(Random.nextInt(128)), l)
-      check(ext, _.packExtensionTypeHeader(ext.getType, ext.getLength), _.unpackExtensionTypeHeader())
-    }
+    for l <- testHeaderLength do
+      val ext =
+        new ExtensionTypeHeader(ExtensionTypeHeader.checkedCastToByte(Random.nextInt(128)), l)
+      check(
+        ext,
+        _.packExtensionTypeHeader(ext.getType, ext.getLength),
+        _.unpackExtensionTypeHeader()
+      )
 
   }
 
@@ -587,31 +562,30 @@ class MessagePackTest extends AirSpec with PropertyCheck with Benchmark {
       aMap,
       { packer =>
         packer.packArrayHeader(aMap.size)
-        for (m <- aMap) {
+        for m <- aMap do
           packer.packMapHeader(m.size)
-          for ((k, v) <- m) {
+          for (k, v) <- m do
             packer.packString(k)
             packer.packString(v)
-          }
-        }
       },
       { unpacker =>
         val v = new Variable()
         unpacker.unpackValue(v)
-        import scala.jdk.CollectionConverters._
-        v.asArrayValue().asScala
+        import scala.jdk.CollectionConverters.*
+        v.asArrayValue()
+          .asScala
           .map { m =>
             val mv  = m.asMapValue()
             val kvs = mv.getKeyValueArray
 
             kvs
               .grouped(2)
-              .map({ kvp: Array[Value] =>
+              .map { (kvp: Array[Value]) =>
                 val k = kvp(0)
                 val v = kvp(1)
 
                 (k.asStringValue().asString, v.asStringValue().asString)
-              })
+              }
               .toMap
           }
           .toList
@@ -624,12 +598,24 @@ class MessagePackTest extends AirSpec with PropertyCheck with Benchmark {
     val posInt  = Gen.chooseNum(0, 1000000000 - 1) // NANOS_PER_SECOND
     forAll(posLong, posInt) { (second: Long, nano: Int) =>
       val v = Instant.ofEpochSecond(second, nano)
-      check(v, { _.packTimestamp(v) }, { _.unpackTimestamp() })
+      check(
+        v, {
+          _.packTimestamp(v)
+        }, {
+          _.unpackTimestamp()
+        }
+      )
     }
     // Using different insterfaces
     forAll(posLong, posInt) { (second: Long, nano: Int) =>
       val v = Instant.ofEpochSecond(second, nano)
-      check(v, { _.packTimestamp(second, nano) }, { _.unpackTimestamp() })
+      check(
+        v, {
+          _.packTimestamp(second, nano)
+        }, {
+          _.unpackTimestamp()
+        }
+      )
     }
     val secLessThan34bits = Gen.chooseNum[Long](0, 1L << 34)
     forAll(secLessThan34bits, posInt) { (second: Long, nano: Int) =>
@@ -642,23 +628,30 @@ class MessagePackTest extends AirSpec with PropertyCheck with Benchmark {
     }
 
     // Corner-cases around uint32 boundaries
-    for (
-      v <- Seq(
-        Instant.ofEpochSecond(Instant.now().getEpochSecond, 123456789L), // uint32 nanoseq (out of int32 range)
-        Instant.ofEpochSecond(-1302749144L, 0),                          // 1928-09-19T21:14:16Z
-        Instant.ofEpochSecond(-747359729L, 0),                           // 1946-04-27T00:04:31Z
-        Instant.ofEpochSecond(4257387427L, 0)                            // 2104-11-29T07:37:07Z
+    for v <- Seq(
+        Instant.ofEpochSecond(
+          Instant.now().getEpochSecond,
+          123456789L
+        ),                                      // uint32 nanoseq (out of int32 range)
+        Instant.ofEpochSecond(-1302749144L, 0), // 1928-09-19T21:14:16Z
+        Instant.ofEpochSecond(-747359729L, 0),  // 1946-04-27T00:04:31Z
+        Instant.ofEpochSecond(4257387427L, 0)   // 2104-11-29T07:37:07Z
       )
-    ) {
+    do
       check(v, _.packTimestamp(v), _.unpackTimestamp())
-    }
   }
 
   test("pack/unpack timestamp in millis") {
     val posLong = Gen.chooseNum[Long](-31557014167219200L, 31556889864403199L)
     forAll(posLong) { (millis: Long) =>
       val v = Instant.ofEpochMilli(millis)
-      check(v, { _.packTimestamp(millis) }, { _.unpackTimestamp() })
+      check(
+        v, {
+          _.packTimestamp(millis)
+        }, {
+          _.unpackTimestamp()
+        }
+      )
     }
   }
 
@@ -666,15 +659,16 @@ class MessagePackTest extends AirSpec with PropertyCheck with Benchmark {
     val posLong = Gen.chooseNum[Long](-31557014167219200L, 31556889864403199L)
     forAll(posLong) { (millis: Long) =>
       val v = Instant.ofEpochMilli(millis)
-      check(v, { _.packTimestamp(millis) },
+      check(
+        v, {
+          _.packTimestamp(millis)
+        },
         { u =>
           val extHeader = u.unpackExtensionTypeHeader()
-          if(extHeader.isTimestampType) {
+          if extHeader.isTimestampType then
             u.unpackTimestamp(extHeader)
-          }
-          else {
+          else
             fail("Cannot reach here")
-          }
         }
       )
     }
@@ -711,12 +705,11 @@ class MessagePackTest extends AirSpec with PropertyCheck with Benchmark {
       a.withBufferSize(64 * 1024).equals(b) shouldBe false
       a.withAllowReadingStringAsBinary(false).equals(b) shouldBe false
       a.withAllowReadingBinaryAsString(false).equals(b) shouldBe false
-      a.withActionOnMalformedString(CodingErrorAction.REPORT)
-        .equals(b) shouldBe false
-      a.withActionOnUnmappableString(CodingErrorAction.REPORT)
-        .equals(b) shouldBe false
+      a.withActionOnMalformedString(CodingErrorAction.REPORT).equals(b) shouldBe false
+      a.withActionOnUnmappableString(CodingErrorAction.REPORT).equals(b) shouldBe false
       a.withStringSizeLimit(32).equals(b) shouldBe false
       a.withStringDecoderBufferSize(32).equals(b) shouldBe false
     }
   }
-}
+
+end MessagePackTest
diff --git a/msgpack-core/src/test/scala/org/msgpack/core/MessagePackerTest.scala b/msgpack-core/src/test/scala/org/msgpack/core/MessagePackerTest.scala
index dea3e4ead..7ff5d82ee 100644
--- a/msgpack-core/src/test/scala/org/msgpack/core/MessagePackerTest.scala
+++ b/msgpack-core/src/test/scala/org/msgpack/core/MessagePackerTest.scala
@@ -26,36 +26,31 @@ import scala.util.Random
 
 /**
   */
-class MessagePackerTest extends AirSpec with Benchmark {
+class MessagePackerTest extends AirSpec with Benchmark:
 
-  private def verifyIntSeq(answer: Array[Int], packed: Array[Byte]): Unit = {
+  private def verifyIntSeq(answer: Array[Int], packed: Array[Byte]): Unit =
     val unpacker = MessagePack.newDefaultUnpacker(packed)
     val b        = Array.newBuilder[Int]
-    while (unpacker.hasNext) {
+    while unpacker.hasNext do
       b += unpacker.unpackInt()
-    }
     val result = b.result()
     result.size shouldBe answer.size
     result shouldBe answer
-  }
 
-  private def createTempFile = {
+  private def createTempFile =
     val f = File.createTempFile("msgpackTest", "msgpack")
     f.deleteOnExit
     f
-  }
 
-  private def createTempFileWithOutputStream = {
+  private def createTempFileWithOutputStream =
     val f   = createTempFile
     val out = new FileOutputStream(f)
     (f, out)
-  }
 
-  private def createTempFileWithChannel = {
+  private def createTempFileWithChannel =
     val (f, out) = createTempFileWithOutputStream
     val ch       = out.getChannel
     (f, ch)
-  }
 
   test("MessagePacker") {
 
@@ -70,16 +65,14 @@ class MessagePackerTest extends AirSpec with Benchmark {
 
       val intSeq2 = intSeq.reverse
       val b2      = new ByteArrayOutputStream
-      packer
-        .reset(new OutputStreamBufferOutput(b2))
+      packer.reset(new OutputStreamBufferOutput(b2))
       intSeq2 foreach packer.packInt
       packer.close
       verifyIntSeq(intSeq2, b2.toByteArray)
 
       val intSeq3 = intSeq2.sorted
       val b3      = new ByteArrayOutputStream
-      packer
-        .reset(new OutputStreamBufferOutput(b3))
+      packer.reset(new OutputStreamBufferOutput(b3))
       intSeq3 foreach packer.packInt
       packer.close
       verifyIntSeq(intSeq3, b3.toByteArray)
@@ -87,43 +80,41 @@ class MessagePackerTest extends AirSpec with Benchmark {
 
     test("improve the performance via reset method") {
       val N = 1000
-      val t = time("packer", repeat = 10) {
-        block("no-buffer-reset") {
-          val out = new ByteArrayOutputStream
-          withResource(MessagePack.newDefaultPacker(out)) { packer =>
-            for (i <- 0 until N) {
-              val outputStream = new ByteArrayOutputStream()
-              packer
-                .reset(new OutputStreamBufferOutput(outputStream))
-              packer.packInt(0)
-              packer.flush()
+      val t =
+        time("packer", repeat = 10) {
+          block("no-buffer-reset") {
+            val out = new ByteArrayOutputStream
+            withResource(MessagePack.newDefaultPacker(out)) { packer =>
+              for i <- 0 until N do
+                val outputStream = new ByteArrayOutputStream()
+                packer.reset(new OutputStreamBufferOutput(outputStream))
+                packer.packInt(0)
+                packer.flush()
             }
           }
-        }
 
-        block("buffer-reset") {
-          val out = new ByteArrayOutputStream
-          withResource(MessagePack.newDefaultPacker(out)) { packer =>
-            val bufferOut =
-              new OutputStreamBufferOutput(new ByteArrayOutputStream())
-            for (i <- 0 until N) {
-              val outputStream = new ByteArrayOutputStream()
-              bufferOut.reset(outputStream)
-              packer.reset(bufferOut)
-              packer.packInt(0)
-              packer.flush()
+          block("buffer-reset") {
+            val out = new ByteArrayOutputStream
+            withResource(MessagePack.newDefaultPacker(out)) { packer =>
+              val bufferOut = new OutputStreamBufferOutput(new ByteArrayOutputStream())
+              for i <- 0 until N do
+                val outputStream = new ByteArrayOutputStream()
+                bufferOut.reset(outputStream)
+                packer.reset(bufferOut)
+                packer.packInt(0)
+                packer.flush()
             }
           }
         }
-      }
 
-      t("buffer-reset").averageWithoutMinMax <= t("no-buffer-reset").averageWithoutMinMax shouldBe true
+      t("buffer-reset").averageWithoutMinMax <= t("no-buffer-reset").averageWithoutMinMax shouldBe
+        true
     }
 
     test("pack larger string array than byte buf") {
       // Based on https://github.com/msgpack/msgpack-java/issues/154
 
-      def test(bufferSize: Int, stringSize: Int): Boolean = {
+      def test(bufferSize: Int, stringSize: Int): Boolean =
         val str       = "a" * stringSize
         val rawString = ValueFactory.newString(str.getBytes("UTF-8"))
         val array     = ValueFactory.newArray(rawString)
@@ -133,16 +124,10 @@ class MessagePackerTest extends AirSpec with Benchmark {
         packer.close()
         out.toByteArray
         true
-      }
 
-      val testCases = Seq(
-        32 -> 30,
-        33 -> 31,
-        32 -> 31,
-        34 -> 32
-      )
-      testCases.foreach {
-        case (bufferSize, stringSize) => test(bufferSize, stringSize)
+      val testCases = Seq(32 -> 30, 33 -> 31, 32 -> 31, 34 -> 32)
+      testCases.foreach { case (bufferSize, stringSize) =>
+        test(bufferSize, stringSize)
       }
     }
 
@@ -152,24 +137,20 @@ class MessagePackerTest extends AirSpec with Benchmark {
       packer.packInt(99)
       packer.close
 
-      val up0 = MessagePack
-        .newDefaultUnpacker(new FileInputStream(f0))
+      val up0 = MessagePack.newDefaultUnpacker(new FileInputStream(f0))
       up0.unpackInt shouldBe 99
       up0.hasNext shouldBe false
       up0.close
 
       val (f1, out1) = createTempFileWithOutputStream
-      packer
-        .reset(new OutputStreamBufferOutput(out1))
+      packer.reset(new OutputStreamBufferOutput(out1))
       packer.packInt(99)
       packer.flush
-      packer
-        .reset(new OutputStreamBufferOutput(out1))
+      packer.reset(new OutputStreamBufferOutput(out1))
       packer.packString("hello")
       packer.close
 
-      val up1 = MessagePack
-        .newDefaultUnpacker(new FileInputStream(f1))
+      val up1 = MessagePack.newDefaultUnpacker(new FileInputStream(f1))
       up1.unpackInt shouldBe 99
       up1.unpackString shouldBe "hello"
       up1.hasNext shouldBe false
@@ -182,24 +163,20 @@ class MessagePackerTest extends AirSpec with Benchmark {
       packer.packInt(99)
       packer.close
 
-      val up0 = MessagePack
-        .newDefaultUnpacker(new FileInputStream(f0))
+      val up0 = MessagePack.newDefaultUnpacker(new FileInputStream(f0))
       up0.unpackInt shouldBe 99
       up0.hasNext shouldBe false
       up0.close
 
       val (f1, out1) = createTempFileWithChannel
-      packer
-        .reset(new ChannelBufferOutput(out1))
+      packer.reset(new ChannelBufferOutput(out1))
       packer.packInt(99)
       packer.flush
-      packer
-        .reset(new ChannelBufferOutput(out1))
+      packer.reset(new ChannelBufferOutput(out1))
       packer.packString("hello")
       packer.close
 
-      val up1 = MessagePack
-        .newDefaultUnpacker(new FileInputStream(f1))
+      val up1 = MessagePack.newDefaultUnpacker(new FileInputStream(f1))
       up1.unpackInt shouldBe 99
       up1.unpackString shouldBe "hello"
       up1.hasNext shouldBe false
@@ -209,32 +186,32 @@ class MessagePackerTest extends AirSpec with Benchmark {
     test("pack a lot of String within expected time") {
       val count = 20000
 
-      def measureDuration(outputStream: java.io.OutputStream) = {
+      def measureDuration(outputStream: java.io.OutputStream) =
         val packer = MessagePack.newDefaultPacker(outputStream)
         var i      = 0
-        while (i < count) {
+        while i < count do
           packer.packString("0123456789ABCDEF")
           i += 1
-        }
         packer.close
-      }
 
-      val t = time("packString into OutputStream", repeat = 10) {
-        block("byte-array-output-stream") {
-          measureDuration(new ByteArrayOutputStream())
-        }
+      val t =
+        time("packString into OutputStream", repeat = 10) {
+          block("byte-array-output-stream") {
+            measureDuration(new ByteArrayOutputStream())
+          }
 
-        block("file-output-stream") {
-          val (_, fileOutput) = createTempFileWithOutputStream
-          measureDuration(fileOutput)
+          block("file-output-stream") {
+            val (_, fileOutput) = createTempFileWithOutputStream
+            measureDuration(fileOutput)
+          }
         }
-      }
-      t("file-output-stream").averageWithoutMinMax < (t("byte-array-output-stream").averageWithoutMinMax * 5) shouldBe true
+      t("file-output-stream").averageWithoutMinMax <
+        (t("byte-array-output-stream").averageWithoutMinMax * 5) shouldBe true
     }
   }
 
   test("compute totalWrittenBytes") {
-    val out = new ByteArrayOutputStream
+    val out                     = new ByteArrayOutputStream
     val packerTotalWrittenBytes =
       withResource(MessagePack.newDefaultPacker(out)) { packer =>
         packer
@@ -255,11 +232,7 @@ class MessagePackerTest extends AirSpec with Benchmark {
   test("support read-only buffer") {
     val payload = Array[Byte](1)
     val out     = new ByteArrayOutputStream()
-    val packer = MessagePack
-      .newDefaultPacker(out)
-      .packBinaryHeader(1)
-      .writePayload(payload)
-      .close()
+    val packer = MessagePack.newDefaultPacker(out).packBinaryHeader(1).writePayload(payload).close()
   }
 
   test("pack small string with STR8") {
@@ -273,8 +246,7 @@ class MessagePackerTest extends AirSpec with Benchmark {
   }
 
   test("be able to disable STR8 for backward compatibility") {
-    val config = new PackerConfig()
-      .withStr8FormatSupport(false)
+    val config = new PackerConfig().withStr8FormatSupport(false)
 
     val packer = config.newBufferPacker()
     packer.packString("Hello. This is a string longer than 32 characters!")
@@ -299,16 +271,14 @@ class MessagePackerTest extends AirSpec with Benchmark {
 
   test("write raw binary") {
     val packer = new MessagePack.PackerConfig().newBufferPacker()
-    val msg =
-      Array[Byte](-127, -92, 116, 121, 112, 101, -92, 112, 105, 110, 103)
+    val msg    = Array[Byte](-127, -92, 116, 121, 112, 101, -92, 112, 105, 110, 103)
     packer.writePayload(msg)
   }
 
   test("append raw binary") {
     val packer = new MessagePack.PackerConfig().newBufferPacker()
-    val msg =
-      Array[Byte](-127, -92, 116, 121, 112, 101, -92, 112, 105, 110, 103)
+    val msg    = Array[Byte](-127, -92, 116, 121, 112, 101, -92, 112, 105, 110, 103)
     packer.addPayload(msg)
   }
 
-}
+end MessagePackerTest
diff --git a/msgpack-core/src/test/scala/org/msgpack/core/MessageUnpackerTest.scala b/msgpack-core/src/test/scala/org/msgpack/core/MessageUnpackerTest.scala
index 720885c45..adab47089 100644
--- a/msgpack-core/src/test/scala/org/msgpack/core/MessageUnpackerTest.scala
+++ b/msgpack-core/src/test/scala/org/msgpack/core/MessageUnpackerTest.scala
@@ -16,41 +16,37 @@
 package org.msgpack.core
 
 import org.msgpack.core.MessagePackSpec.{createMessagePackData, toHex}
-import org.msgpack.core.buffer._
+import org.msgpack.core.buffer.*
 import org.msgpack.value.ValueType
 import wvlet.airspec.AirSpec
 import wvlet.log.LogSupport
 import wvlet.log.io.IOUtil.withResource
 
-import java.io._
+import java.io.*
 import java.nio.ByteBuffer
 import java.util.Collections
-import scala.jdk.CollectionConverters._
+import scala.jdk.CollectionConverters.*
 import scala.util.Random
 
-object MessageUnpackerTest {
-  class SplitMessageBufferInput(array: Array[Array[Byte]]) extends MessageBufferInput {
-    var cursor = 0
-    override def next(): MessageBuffer = {
-      if (cursor < array.length) {
+object MessageUnpackerTest:
+  class SplitMessageBufferInput(array: Array[Array[Byte]]) extends MessageBufferInput:
+    var cursor                         = 0
+    override def next(): MessageBuffer =
+      if cursor < array.length then
         val a = array(cursor)
         cursor += 1
         MessageBuffer.wrap(a)
-      } else {
+      else
         null
-      }
-    }
 
     override def close(): Unit = {}
-  }
-}
 
-import org.msgpack.core.MessageUnpackerTest._
+import org.msgpack.core.MessageUnpackerTest.*
 
-class MessageUnpackerTest extends AirSpec with Benchmark {
+class MessageUnpackerTest extends AirSpec with Benchmark:
 
-  private val universal = MessageBuffer.allocate(0).isInstanceOf[MessageBufferU]
-  private def testData: Array[Byte] = {
+  private val universal             = MessageBuffer.allocate(0).isInstanceOf[MessageBufferU]
+  private def testData: Array[Byte] =
     val out    = new ByteArrayOutputStream()
     val packer = MessagePack.newDefaultPacker(out)
 
@@ -68,17 +64,18 @@ class MessageUnpackerTest extends AirSpec with Benchmark {
     debug(s"packed: ${toHex(arr)}, size:${arr.length}")
 
     arr
-  }
 
-  private val intSeq = (for (i <- 0 until 100) yield Random.nextInt()).toArray[Int]
+  private val intSeq =
+    (
+      for (i <- 0 until 100)
+        yield Random.nextInt()
+    ).toArray[Int]
 
-  private def testData2: Array[Byte] = {
+  private def testData2: Array[Byte] =
     val out    = new ByteArrayOutputStream()
     val packer = MessagePack.newDefaultPacker(out);
 
-    packer
-      .packBoolean(true)
-      .packBoolean(false)
+    packer.packBoolean(true).packBoolean(false)
 
     intSeq.foreach(packer.packInt)
     packer.close()
@@ -86,15 +83,15 @@ class MessageUnpackerTest extends AirSpec with Benchmark {
     val arr = out.toByteArray
     debug(s"packed: ${toHex(arr)}")
     arr
-  }
 
-  private def write(packer: MessagePacker, r: Random): Unit = {
-    val tpeIndex = Iterator
-      .continually(r.nextInt(MessageFormat.values().length))
-      .find(_ != MessageFormat.NEVER_USED.ordinal())
-      .get
+  private def write(packer: MessagePacker, r: Random): Unit =
+    val tpeIndex =
+      Iterator
+        .continually(r.nextInt(MessageFormat.values().length))
+        .find(_ != MessageFormat.NEVER_USED.ordinal())
+        .get
     val tpe = MessageFormat.values()(tpeIndex)
-    tpe.getValueType match {
+    tpe.getValueType match
 
       case ValueType.INTEGER =>
         val v = r.nextInt(Int.MaxValue)
@@ -124,27 +121,27 @@ class MessageUnpackerTest extends AirSpec with Benchmark {
         trace(s"array len: $len")
         packer.packArrayHeader(len)
         var i = 0
-        while (i < len) {
+        while i < len do
           write(packer, r)
           i += 1
-        }
       case ValueType.MAP =>
         val len = r.nextInt(5) + 1
         packer.packMapHeader(len)
         trace(s"map len: ${len}")
         var i = 0
-        while (i < len * 2) {
+        while i < len * 2 do
           write(packer, r)
           i += 1
-        }
       case _ =>
         val v = r.nextInt(Int.MaxValue)
         trace(s"int: $v")
         packer.packInt(v)
-    }
-  }
 
-  private def testData3(N: Int): Array[Byte] = {
+    end match
+
+  end write
+
+  private def testData3(N: Int): Array[Byte] =
 
     val out    = new ByteArrayOutputStream()
     val packer = MessagePack.newDefaultPacker(out)
@@ -160,11 +157,10 @@ class MessageUnpackerTest extends AirSpec with Benchmark {
     trace(s"packed: ${toHex(arr)}")
     debug(s"size:${arr.length}")
     arr
-  }
 
-  private def readValue(unpacker: MessageUnpacker): Unit = {
+  private def readValue(unpacker: MessageUnpacker): Unit =
     val f = unpacker.getNextFormat()
-    f.getValueType match {
+    f.getValueType match
       case ValueType.ARRAY =>
         val arrLen = unpacker.unpackArrayHeader()
         debug(s"arr size: $arrLen")
@@ -180,24 +176,20 @@ class MessageUnpackerTest extends AirSpec with Benchmark {
       case other =>
         unpacker.skipValue()
         debug(s"unknown type: $f")
-    }
-  }
 
-  private def createTempFile: File = {
+  private def createTempFile: File =
     val f = File.createTempFile("msgpackTest", "msgpack")
     f.deleteOnExit
     val p = MessagePack.newDefaultPacker(new FileOutputStream(f))
     p.packInt(99)
     p.close
     f
-  }
 
-  private def checkFile(u: MessageUnpacker): Boolean = {
+  private def checkFile(u: MessageUnpacker): Boolean =
     u.unpackInt shouldBe 99
     u.hasNext shouldBe false
-  }
 
-  private def unpackers(data: Array[Byte]): Seq[MessageUnpacker] = {
+  private def unpackers(data: Array[Byte]): Seq[MessageUnpacker] =
     val bb = ByteBuffer.allocate(data.length)
     val db = ByteBuffer.allocateDirect(data.length)
     bb.put(data).flip()
@@ -205,20 +197,21 @@ class MessageUnpackerTest extends AirSpec with Benchmark {
     val builder = Seq.newBuilder[MessageUnpacker]
     builder += MessagePack.newDefaultUnpacker(data)
     builder += MessagePack.newDefaultUnpacker(bb)
-    if (!universal) {
+    if !universal then
       builder += MessagePack.newDefaultUnpacker(db)
-    }
 
     builder.result()
-  }
 
-  private def unpackerCollectionWithVariousBuffers(data: Array[Byte], chunkSize: Int): Seq[MessageUnpacker] = {
+  private def unpackerCollectionWithVariousBuffers(
+      data: Array[Byte],
+      chunkSize: Int
+  ): Seq[MessageUnpacker] =
     val seqBytes         = Seq.newBuilder[MessageBufferInput]
     val seqByteBuffers   = Seq.newBuilder[MessageBufferInput]
     val seqDirectBuffers = Seq.newBuilder[MessageBufferInput]
     var left             = data.length
     var position         = 0
-    while (left > 0) {
+    while left > 0 do
       val length = Math.min(chunkSize, left)
       seqBytes += new ArrayBufferInput(data, position, length)
       val bb = ByteBuffer.allocate(length)
@@ -229,46 +222,56 @@ class MessageUnpackerTest extends AirSpec with Benchmark {
       seqDirectBuffers += new ByteBufferInput(db)
       left -= length
       position += length
-    }
     val builder = Seq.newBuilder[MessageUnpacker]
-    builder += MessagePack.newDefaultUnpacker(new SequenceMessageBufferInput(Collections.enumeration(seqBytes.result().asJava)))
-    builder += MessagePack.newDefaultUnpacker(new SequenceMessageBufferInput(Collections.enumeration(seqByteBuffers.result().asJava)))
-    if (!universal) {
-      builder += MessagePack.newDefaultUnpacker(new SequenceMessageBufferInput(Collections.enumeration(seqDirectBuffers.result().asJava)))
-    }
+    builder +=
+      MessagePack.newDefaultUnpacker(
+        new SequenceMessageBufferInput(Collections.enumeration(seqBytes.result().asJava))
+      )
+    builder +=
+      MessagePack.newDefaultUnpacker(
+        new SequenceMessageBufferInput(Collections.enumeration(seqByteBuffers.result().asJava))
+      )
+    if !universal then
+      builder +=
+        MessagePack.newDefaultUnpacker(
+          new SequenceMessageBufferInput(Collections.enumeration(seqDirectBuffers.result().asJava))
+        )
 
     builder.result()
-  }
+
+  end unpackerCollectionWithVariousBuffers
 
   test("MessageUnpacker") {
 
     test("parse message packed data") {
       val arr = testData
 
-      for (unpacker <- unpackers(arr)) {
+      for unpacker <- unpackers(arr) do
 
         var count = 0
-        while (unpacker.hasNext) {
+        while unpacker.hasNext do
           count += 1
           readValue(unpacker)
-        }
         count shouldBe 6
         unpacker.getTotalReadBytes shouldBe arr.length
-      }
+
+        unpacker.close()
+        unpacker.getTotalReadBytes shouldBe arr.length
     }
 
     test("skip reading values") {
 
-      for (unpacker <- unpackers(testData)) {
+      for unpacker <- unpackers(testData) do
         var skipCount = 0
-        while (unpacker.hasNext) {
+        while unpacker.hasNext do
           unpacker.skipValue()
           skipCount += 1
-        }
 
         skipCount shouldBe 2
         unpacker.getTotalReadBytes shouldBe testData.length
-      }
+
+        unpacker.close()
+        unpacker.getTotalReadBytes shouldBe testData.length
     }
 
     test("compare skip performance") {
@@ -277,23 +280,20 @@ class MessageUnpackerTest extends AirSpec with Benchmark {
 
       time("skip performance", repeat = 100) {
         block("switch") {
-          for (unpacker <- unpackers(data)) {
+          for unpacker <- unpackers(data) do
             var skipCount = 0
-            while (unpacker.hasNext) {
+            while unpacker.hasNext do
               unpacker.skipValue()
               skipCount += 1
-            }
             skipCount shouldBe N
-          }
         }
       }
 
       time("bulk skip performance", repeat = 100) {
         block("switch") {
-          for (unpacker <- unpackers(data)) {
+          for unpacker <- unpackers(data) do
             unpacker.skipValue(N)
             unpacker.hasNext shouldBe false
-          }
         }
       }
 
@@ -302,12 +302,12 @@ class MessageUnpackerTest extends AirSpec with Benchmark {
     test("parse int data") {
       debug(intSeq.mkString(", "))
 
-      for (unpacker <- unpackers(testData2)) {
+      for unpacker <- unpackers(testData2) do
         val ib = Seq.newBuilder[Int]
 
-        while (unpacker.hasNext) {
+        while unpacker.hasNext do
           val f = unpacker.getNextFormat
-          f.getValueType match {
+          f.getValueType match
             case ValueType.INTEGER =>
               val i = unpacker.unpackInt()
               trace(f"read int: $i%,d")
@@ -317,48 +317,48 @@ class MessageUnpackerTest extends AirSpec with Benchmark {
               trace(s"read boolean: $b")
             case other =>
               unpacker.skipValue()
-          }
-        }
 
         ib.result() shouldBe intSeq.toSeq
         unpacker.getTotalReadBytes shouldBe testData2.length
-      }
+
+        unpacker.close()
+        unpacker.getTotalReadBytes shouldBe testData2.length
     }
 
     test("read data at the buffer boundary") {
-      trait SplitTest extends LogSupport {
+      trait SplitTest extends LogSupport:
         val data: Array[Byte]
-        def run: Unit = {
-          for (unpacker <- unpackers(data)) {
-            val numElems = {
+        def run: Unit =
+          for unpacker <- unpackers(data) do
+            val numElems =
               var c = 0
-              while (unpacker.hasNext) {
+              while unpacker.hasNext do
                 readValue(unpacker)
                 c += 1
-              }
               c
-            }
 
-            for (splitPoint <- 1 until data.length - 1) {
+            for splitPoint <- 1 until data.length - 1 do
               debug(s"split at $splitPoint")
               val (h, t)   = data.splitAt(splitPoint)
               val bin      = new SplitMessageBufferInput(Array(h, t))
               val unpacker = MessagePack.newDefaultUnpacker(bin)
               var count    = 0
-              while (unpacker.hasNext) {
+              while unpacker.hasNext do
                 count += 1
                 val f = unpacker.getNextFormat
                 readValue(unpacker)
-              }
               count shouldBe numElems
               unpacker.getTotalReadBytes shouldBe data.length
-            }
-          }
-        }
-      }
 
-      new SplitTest { val data = testData }.run
-      new SplitTest { val data = testData3(30) }.run
+              unpacker.close()
+              unpacker.getTotalReadBytes shouldBe data.length
+
+      new SplitTest:
+        val data = testData
+      .run
+      new SplitTest:
+        val data = testData3(30)
+      .run
     }
 
     test("read integer at MessageBuffer boundaries") {
@@ -370,18 +370,21 @@ class MessageUnpackerTest extends AirSpec with Benchmark {
       val data = packer.toByteArray
 
       // Boundary test
-      withResource(MessagePack.newDefaultUnpacker(new InputStreamBufferInput(new ByteArrayInputStream(data), 8192))) { unpacker =>
+      withResource(
+        MessagePack.newDefaultUnpacker(
+          new InputStreamBufferInput(new ByteArrayInputStream(data), 8192)
+        )
+      ) { unpacker =>
         (0 until 1170).foreach { i =>
           unpacker.unpackLong() shouldBe 0x0011223344556677L
         }
       }
 
       // Boundary test for sequences of ByteBuffer, DirectByteBuffer backed MessageInput.
-      for (unpacker <- unpackerCollectionWithVariousBuffers(data, 32)) {
+      for unpacker <- unpackerCollectionWithVariousBuffers(data, 32) do
         (0 until 1170).foreach { i =>
           unpacker.unpackLong() shouldBe 0x0011223344556677L
         }
-      }
     }
 
     test("read string at MessageBuffer boundaries") {
@@ -393,36 +396,34 @@ class MessageUnpackerTest extends AirSpec with Benchmark {
       val data = packer.toByteArray
 
       // Boundary test
-      withResource(MessagePack.newDefaultUnpacker(new InputStreamBufferInput(new ByteArrayInputStream(data), 8192))) { unpacker =>
+      withResource(
+        MessagePack.newDefaultUnpacker(
+          new InputStreamBufferInput(new ByteArrayInputStream(data), 8192)
+        )
+      ) { unpacker =>
         (0 until 1170).foreach { i =>
           unpacker.unpackString() shouldBe "hello world"
         }
       }
 
       // Boundary test for sequences of ByteBuffer, DirectByteBuffer backed MessageInput.
-      for (unpacker <- unpackerCollectionWithVariousBuffers(data, 32)) {
+      for unpacker <- unpackerCollectionWithVariousBuffers(data, 32) do
         (0 until 1170).foreach { i =>
           unpacker.unpackString() shouldBe "hello world"
         }
-      }
     }
 
     test("be faster than msgpack-v6 skip") {
 
-      trait Fixture {
+      trait Fixture:
         val unpacker: MessageUnpacker
-        def run: Unit = {
+        def run: Unit =
           var count = 0
-          try {
-            while (unpacker.hasNext) {
+          try
+            while unpacker.hasNext do
               unpacker.skipValue()
               count += 1
-            }
-          } finally {
-            unpacker.close()
-          }
-        }
-      }
+          finally unpacker.close()
 
       val data = testData3(10000)
       val N    = 100
@@ -431,64 +432,69 @@ class MessageUnpackerTest extends AirSpec with Benchmark {
       val db = ByteBuffer.allocateDirect(data.length)
       db.put(data).flip()
 
-      val t = time("skip performance", repeat = N) {
-        block("v6") {
-          val v6       = new org.msgpack.MessagePack()
-          val unpacker = new org.msgpack.unpacker.MessagePackUnpacker(v6, new ByteArrayInputStream(data))
-          var count    = 0
-          try {
-            while (true) {
-              unpacker.skip()
-              count += 1
-            }
-          } catch {
-            case e: EOFException =>
-          } finally unpacker.close()
-        }
+      val t =
+        time("skip performance", repeat = N) {
+          block("v6") {
+            val v6       = new org.msgpack.MessagePack()
+            val unpacker =
+              new org.msgpack.unpacker.MessagePackUnpacker(v6, new ByteArrayInputStream(data))
+            var count = 0
+            try
+              while true do
+                unpacker.skip()
+                count += 1
+            catch
+              case e: EOFException =>
+            finally
+              unpacker.close()
+          }
 
-        block("v7-array") {
-          new Fixture {
-            override val unpacker = MessagePack.newDefaultUnpacker(data)
-          }.run
-        }
+          block("v7-array") {
+            new Fixture:
+              override val unpacker = MessagePack.newDefaultUnpacker(data)
+            .run
+          }
 
-        block("v7-array-buffer") {
-          new Fixture {
-            override val unpacker = MessagePack.newDefaultUnpacker(bb)
-          }.run
-        }
-        if (!universal) block("v7-direct-buffer") {
-          new Fixture {
-            override val unpacker = MessagePack.newDefaultUnpacker(db)
-          }.run
+          block("v7-array-buffer") {
+            new Fixture:
+              override val unpacker = MessagePack.newDefaultUnpacker(bb)
+            .run
+          }
+          if !universal then
+            block("v7-direct-buffer") {
+              new Fixture:
+                override val unpacker = MessagePack.newDefaultUnpacker(db)
+              .run
+            }
         }
-      }
 
       t("v7-array").averageWithoutMinMax <= t("v6").averageWithoutMinMax shouldBe true
       t("v7-array-buffer").averageWithoutMinMax <= t("v6").averageWithoutMinMax shouldBe true
-      if (!universal) {
+      if !universal then
         t("v7-direct-buffer").averageWithoutMinMax <= t("v6").averageWithoutMinMax shouldBe true
-      }
     }
 
-    import org.msgpack.`type`.{ValueType => ValueTypeV6}
+    import org.msgpack.`type`.ValueType as ValueTypeV6
 
     test("be faster than msgpack-v6 read value") {
 
-      def readValueV6(unpacker: org.msgpack.unpacker.MessagePackUnpacker): Unit = {
+      def readValueV6(unpacker: org.msgpack.unpacker.MessagePackUnpacker): Unit =
         val vt = unpacker.getNextType()
-        vt match {
+        vt match
           case ValueTypeV6.ARRAY =>
             val len = unpacker.readArrayBegin()
             var i   = 0
-            while (i < len) { readValueV6(unpacker); i += 1 }
+            while i < len do
+              readValueV6(unpacker);
+              i += 1
             unpacker.readArrayEnd()
           case ValueTypeV6.MAP =>
             val len = unpacker.readMapBegin()
             var i   = 0
-            while (i < len) {
-              readValueV6(unpacker); readValueV6(unpacker); i += 1
-            }
+            while i < len do
+              readValueV6(unpacker);
+              readValueV6(unpacker);
+              i += 1
             unpacker.readMapEnd()
           case ValueTypeV6.NIL =>
             unpacker.readNil()
@@ -502,23 +508,27 @@ class MessageUnpackerTest extends AirSpec with Benchmark {
             unpacker.readByteArray()
           case _ =>
             unpacker.skip()
-        }
-      }
+      end readValueV6
 
       val buf = new Array[Byte](8192)
 
-      def readValue(unpacker: MessageUnpacker): Unit = {
+      def readValue(unpacker: MessageUnpacker): Unit =
         val f  = unpacker.getNextFormat
         val vt = f.getValueType
-        vt match {
+        vt match
           case ValueType.ARRAY =>
             val len = unpacker.unpackArrayHeader()
             var i   = 0
-            while (i < len) { readValue(unpacker); i += 1 }
+            while i < len do
+              readValue(unpacker);
+              i += 1
           case ValueType.MAP =>
             val len = unpacker.unpackMapHeader()
             var i   = 0
-            while (i < len) { readValue(unpacker); readValue(unpacker); i += 1 }
+            while i < len do
+              readValue(unpacker);
+              readValue(unpacker);
+              i += 1
           case ValueType.NIL =>
             unpacker.unpackNil()
           case ValueType.INTEGER =>
@@ -535,20 +545,17 @@ class MessageUnpackerTest extends AirSpec with Benchmark {
             unpacker.readPayload(buf, 0, len)
           case _ =>
             unpacker.skipValue()
-        }
-      }
-      trait Fixture {
+        end match
+      end readValue
+      trait Fixture:
         val unpacker: MessageUnpacker
-        def run: Unit = {
+        def run: Unit =
           var count = 0
-          try {
-            while (unpacker.hasNext) {
+          try
+            while unpacker.hasNext do
               readValue(unpacker)
               count += 1
-            }
-          } finally unpacker.close()
-        }
-      }
+          finally unpacker.close()
 
       val data = testData3(10000)
       val N    = 100
@@ -557,49 +564,55 @@ class MessageUnpackerTest extends AirSpec with Benchmark {
       val db = ByteBuffer.allocateDirect(data.length)
       db.put(data).flip()
 
-      val t = time("unpack performance", repeat = N) {
-        block("v6") {
-          val v6       = new org.msgpack.MessagePack()
-          val unpacker = new org.msgpack.unpacker.MessagePackUnpacker(v6, new ByteArrayInputStream(data))
-          var count    = 0
-          try {
-            while (true) {
-              readValueV6(unpacker)
-              count += 1
-            }
-          } catch {
-            case e: EOFException =>
-          } finally unpacker.close()
-        }
+      val t =
+        time("unpack performance", repeat = N) {
+          block("v6") {
+            val v6       = new org.msgpack.MessagePack()
+            val unpacker =
+              new org.msgpack.unpacker.MessagePackUnpacker(v6, new ByteArrayInputStream(data))
+            var count = 0
+            try
+              while true do
+                readValueV6(unpacker)
+                count += 1
+            catch
+              case e: EOFException =>
+            finally
+              unpacker.close()
+          }
 
-        block("v7-array") {
-          new Fixture {
-            override val unpacker = MessagePack.newDefaultUnpacker(data)
-          }.run
-        }
+          block("v7-array") {
+            new Fixture:
+              override val unpacker = MessagePack.newDefaultUnpacker(data)
+            .run
+          }
 
-        block("v7-array-buffer") {
-          new Fixture {
-            override val unpacker = MessagePack.newDefaultUnpacker(bb)
-          }.run
-        }
+          block("v7-array-buffer") {
+            new Fixture:
+              override val unpacker = MessagePack.newDefaultUnpacker(bb)
+            .run
+          }
 
-        if (!universal) block("v7-direct-buffer") {
-          new Fixture {
-            override val unpacker = MessagePack.newDefaultUnpacker(db)
-          }.run
+          if !universal then
+            block("v7-direct-buffer") {
+              new Fixture:
+                override val unpacker = MessagePack.newDefaultUnpacker(db)
+              .run
+            }
         }
-      }
 
-      if (t("v7-array").averageWithoutMinMax > t("v6").averageWithoutMinMax) {
-        warn(s"v7-array ${t("v7-array").averageWithoutMinMax} is slower than v6 ${t("v6").averageWithoutMinMax}")
-      }
-      if (t("v7-array-buffer").averageWithoutMinMax > t("v6").averageWithoutMinMax) {
-        warn(s"v7-array-buffer ${t("v7-array-buffer").averageWithoutMinMax} is slower than v6 ${t("v6").averageWithoutMinMax}")
-      }
-      if (!universal) {
+      if t("v7-array").averageWithoutMinMax > t("v6").averageWithoutMinMax then
+        warn(
+          s"v7-array ${t("v7-array").averageWithoutMinMax} is slower than v6 ${t("v6")
+              .averageWithoutMinMax}"
+        )
+      if t("v7-array-buffer").averageWithoutMinMax > t("v6").averageWithoutMinMax then
+        warn(
+          s"v7-array-buffer ${t("v7-array-buffer").averageWithoutMinMax} is slower than v6 ${t("v6")
+              .averageWithoutMinMax}"
+        )
+      if !universal then
         t("v7-direct-buffer").averageWithoutMinMax <= t("v6").averageWithoutMinMax shouldBe true
-      }
     }
 
     test("be faster for reading binary than v6") {
@@ -614,31 +627,26 @@ class MessageUnpackerTest extends AirSpec with Benchmark {
       }
       packer.close()
 
-      trait Fixture {
+      trait Fixture:
         val unpacker: MessageUnpacker
         val loop: Int
-        def run: Unit = {
+        def run: Unit =
           var i = 0
-          try {
-            while (i < loop) {
+          try
+            while i < loop do
               val len = unpacker.unpackBinaryHeader()
               val out = new Array[Byte](len)
               unpacker.readPayload(out, 0, len)
               i += 1
-            }
-          } finally unpacker.close()
-        }
-        def runRef: Unit = {
+          finally unpacker.close()
+        def runRef: Unit =
           var i = 0
-          try {
-            while (i < loop) {
+          try
+            while i < loop do
               val len = unpacker.unpackBinaryHeader()
               val out = unpacker.readPayloadAsReference(len)
               i += 1
-            }
-          } finally unpacker.close()
-        }
-      }
+          finally unpacker.close()
       val b  = bos.toByteArray
       val bb = ByteBuffer.allocate(b.length)
       bb.put(b).flip()
@@ -648,65 +656,66 @@ class MessageUnpackerTest extends AirSpec with Benchmark {
       time("unpackBinary", repeat = 100) {
         block("v6") {
           val v6       = new org.msgpack.MessagePack()
-          val unpacker = new org.msgpack.unpacker.MessagePackUnpacker(v6, new ByteArrayInputStream(b))
-          var i        = 0
-          while (i < R) {
+          val unpacker =
+            new org.msgpack.unpacker.MessagePackUnpacker(v6, new ByteArrayInputStream(b))
+          var i = 0
+          while i < R do
             val out = unpacker.readByteArray()
             i += 1
-          }
           unpacker.close()
         }
 
         block("v7-array") {
-          new Fixture {
+          new Fixture:
             override val unpacker = MessagePack.newDefaultUnpacker(b)
             override val loop     = R
-          }.run
+          .run
         }
 
         block("v7-array-buffer") {
-          new Fixture {
+          new Fixture:
             override val unpacker = MessagePack.newDefaultUnpacker(bb)
             override val loop     = R
-          }.run
+          .run
         }
 
-        if (!universal) block("v7-direct-buffer") {
-          new Fixture {
-            override val unpacker = MessagePack.newDefaultUnpacker(db)
-            override val loop     = R
-          }.run
-        }
+        if !universal then
+          block("v7-direct-buffer") {
+            new Fixture:
+              override val unpacker = MessagePack.newDefaultUnpacker(db)
+              override val loop     = R
+            .run
+          }
 
         block("v7-ref-array") {
-          new Fixture {
+          new Fixture:
             override val unpacker = MessagePack.newDefaultUnpacker(b)
             override val loop     = R
-          }.runRef
+          .runRef
         }
 
         block("v7-ref-array-buffer") {
-          new Fixture {
+          new Fixture:
             override val unpacker = MessagePack.newDefaultUnpacker(bb)
             override val loop     = R
-          }.runRef
+          .runRef
         }
 
-        if (!universal) block("v7-ref-direct-buffer") {
-          new Fixture {
-            override val unpacker = MessagePack.newDefaultUnpacker(db)
-            override val loop     = R
-          }.runRef
-        }
+        if !universal then
+          block("v7-ref-direct-buffer") {
+            new Fixture:
+              override val unpacker = MessagePack.newDefaultUnpacker(db)
+              override val loop     = R
+            .runRef
+          }
       }
     }
 
     test("read payload as a reference") {
 
-      val dataSizes =
-        Seq(0, 1, 5, 8, 16, 32, 128, 256, 1024, 2000, 10000, 100000)
+      val dataSizes = Seq(0, 1, 5, 8, 16, 32, 128, 256, 1024, 2000, 10000, 100000)
 
-      for (s <- dataSizes) {
+      for s <- dataSizes do
         test(f"data size is $s%,d") {
           val data = new Array[Byte](s)
           Random.nextBytes(data)
@@ -716,7 +725,7 @@ class MessageUnpackerTest extends AirSpec with Benchmark {
           packer.writePayload(data)
           packer.close()
 
-          for (unpacker <- unpackers(b.toByteArray)) {
+          for unpacker <- unpackers(b.toByteArray) do
             val len = unpacker.unpackBinaryHeader()
             len shouldBe s
             val ref = unpacker.readPayloadAsReference(len)
@@ -726,21 +735,18 @@ class MessageUnpackerTest extends AirSpec with Benchmark {
             ref.getBytes(0, stored, 0, len)
 
             stored shouldBe data
-          }
         }
-      }
     }
 
     test("reset the internal states") {
 
       val data = intSeq
       val b    = createMessagePackData(packer => data foreach packer.packInt)
-      for (unpacker <- unpackers(b)) {
+      for unpacker <- unpackers(b) do
 
         val unpacked = Array.newBuilder[Int]
-        while (unpacker.hasNext) {
+        while unpacker.hasNext do
           unpacked += unpacker.unpackInt()
-        }
         unpacker.close
         unpacked.result() shouldBe data
 
@@ -749,9 +755,8 @@ class MessageUnpackerTest extends AirSpec with Benchmark {
         val bi    = new ArrayBufferInput(b2)
         unpacker.reset(bi)
         val unpacked2 = Array.newBuilder[Int]
-        while (unpacker.hasNext) {
+        while unpacker.hasNext do
           unpacked2 += unpacker.unpackInt()
-        }
         unpacker.close
         unpacked2.result() shouldBe data2
 
@@ -759,12 +764,10 @@ class MessageUnpackerTest extends AirSpec with Benchmark {
         bi.reset(b2)
         unpacker.reset(bi)
         val unpacked3 = Array.newBuilder[Int]
-        while (unpacker.hasNext) {
+        while unpacker.hasNext do
           unpacked3 += unpacker.unpackInt()
-        }
         unpacker.close
         unpacked3.result() shouldBe data2
-      }
 
     }
 
@@ -778,42 +781,40 @@ class MessageUnpackerTest extends AirSpec with Benchmark {
       val mb  = MessageBuffer.wrap(arr)
 
       val N = 1000
-      val t = time("unpacker", repeat = 10) {
-        block("no-buffer-reset") {
-          withResource(MessagePack.newDefaultUnpacker(arr)) { unpacker =>
-            for (i <- 0 until N) {
-              val buf = new ArrayBufferInput(arr)
-              unpacker.reset(buf)
-              unpacker.unpackInt
-              unpacker.close
+      val t =
+        time("unpacker", repeat = 10) {
+          block("no-buffer-reset") {
+            withResource(MessagePack.newDefaultUnpacker(arr)) { unpacker =>
+              for i <- 0 until N do
+                val buf = new ArrayBufferInput(arr)
+                unpacker.reset(buf)
+                unpacker.unpackInt
+                unpacker.close
             }
           }
-        }
 
-        block("reuse-array-input") {
-          withResource(MessagePack.newDefaultUnpacker(arr)) { unpacker =>
-            val buf = new ArrayBufferInput(arr)
-            for (i <- 0 until N) {
-              buf.reset(arr)
-              unpacker.reset(buf)
-              unpacker.unpackInt
-              unpacker.close
+          block("reuse-array-input") {
+            withResource(MessagePack.newDefaultUnpacker(arr)) { unpacker =>
+              val buf = new ArrayBufferInput(arr)
+              for i <- 0 until N do
+                buf.reset(arr)
+                unpacker.reset(buf)
+                unpacker.unpackInt
+                unpacker.close
             }
           }
-        }
 
-        block("reuse-message-buffer") {
-          withResource(MessagePack.newDefaultUnpacker(arr)) { unpacker =>
-            val buf = new ArrayBufferInput(arr)
-            for (i <- 0 until N) {
-              buf.reset(mb)
-              unpacker.reset(buf)
-              unpacker.unpackInt
-              unpacker.close
+          block("reuse-message-buffer") {
+            withResource(MessagePack.newDefaultUnpacker(arr)) { unpacker =>
+              val buf = new ArrayBufferInput(arr)
+              for i <- 0 until N do
+                buf.reset(mb)
+                unpacker.reset(buf)
+                unpacker.unpackInt
+                unpacker.close
             }
           }
         }
-      }
 
       // This performance comparison is too close, so we disabled it
       // t("reuse-message-buffer").averageWithoutMinMax should be <= t("no-buffer-reset").averageWithoutMinMax
@@ -845,36 +846,34 @@ class MessageUnpackerTest extends AirSpec with Benchmark {
     }
 
     test("unpack large string data") {
-      def createLargeData(stringLength: Int): Array[Byte] = {
+      def createLargeData(stringLength: Int): Array[Byte] =
         val out    = new ByteArrayOutputStream()
         val packer = MessagePack.newDefaultPacker(out)
 
-        packer
-          .packArrayHeader(2)
-          .packString("l" * stringLength)
-          .packInt(1)
+        packer.packArrayHeader(2).packString("l" * stringLength).packInt(1)
 
         packer.close()
 
         out.toByteArray
-      }
 
       Seq(8191, 8192, 8193, 16383, 16384, 16385).foreach { n =>
         val arr = createLargeData(n)
 
-        for (unpacker <- unpackers(arr)) {
+        for unpacker <- unpackers(arr) do
 
           unpacker.unpackArrayHeader shouldBe 2
           unpacker.unpackString.length shouldBe n
           unpacker.unpackInt shouldBe 1
 
           unpacker.getTotalReadBytes shouldBe arr.length
-        }
+
+          unpacker.close()
+          unpacker.getTotalReadBytes shouldBe arr.length
       }
     }
 
     test("unpack string crossing end of buffer") {
-      def check(expected: String, strLen: Int) = {
+      def check(expected: String, strLen: Int) =
         val bytes = new Array[Byte](strLen)
         val out   = new ByteArrayOutputStream
 
@@ -884,52 +883,58 @@ class MessageUnpackerTest extends AirSpec with Benchmark {
         packer.packString(expected)
         packer.close
 
-        val unpacker = MessagePack.newDefaultUnpacker(new InputStreamBufferInput(new ByteArrayInputStream(out.toByteArray)))
-        val len      = unpacker.unpackBinaryHeader
+        val unpacker = MessagePack.newDefaultUnpacker(
+          new InputStreamBufferInput(new ByteArrayInputStream(out.toByteArray))
+        )
+        val len = unpacker.unpackBinaryHeader
         unpacker.readPayload(len)
         val got = unpacker.unpackString
         unpacker.close
 
         got shouldBe expected
-      }
 
-      Seq("\u3042", "a\u3042", "\u3042a", "\u3042\u3044\u3046\u3048\u304A\u304B\u304D\u304F\u3051\u3053\u3055\u3057\u3059\u305B\u305D")
-        .foreach { s =>
-          Seq(8185, 8186, 8187, 8188, 16377, 16378, 16379, 16380).foreach { n =>
-            check(s, n)
-          }
+      Seq(
+        "\u3042",
+        "a\u3042",
+        "\u3042a",
+        "\u3042\u3044\u3046\u3048\u304A\u304B\u304D\u304F\u3051\u3053\u3055\u3057\u3059\u305B\u305D"
+      ).foreach { s =>
+        Seq(8185, 8186, 8187, 8188, 16377, 16378, 16379, 16380).foreach { n =>
+          check(s, n)
         }
+      }
     }
 
-    def readTest(input: MessageBufferInput): Unit = {
+    def readTest(input: MessageBufferInput): Unit =
       withResource(MessagePack.newDefaultUnpacker(input)) { unpacker =>
-        while (unpacker.hasNext) {
+        while unpacker.hasNext do
           unpacker.unpackValue()
-        }
       }
-    }
 
     test("read value length at buffer boundary") {
-      val input = new SplitMessageBufferInput(
-        Array(
-          Array[Byte](MessagePack.Code.STR16),
-          Array[Byte](0x00),
-          Array[Byte](0x05), // STR16 length at the boundary
-          "hello".getBytes(MessagePack.UTF8)
+      val input =
+        new SplitMessageBufferInput(
+          Array(
+            Array[Byte](MessagePack.Code.STR16),
+            Array[Byte](0x00),
+            Array[Byte](0x05), // STR16 length at the boundary
+            "hello".getBytes(MessagePack.UTF8)
+          )
         )
-      )
       readTest(input)
 
-      val input2 = new SplitMessageBufferInput(
-        Array(
-          Array[Byte](MessagePack.Code.STR32),
-          Array[Byte](0x00),
-          Array[Byte](0x00, 0x00),
-          Array[Byte](0x05), // STR32 length at the boundary
-          "hello".getBytes(MessagePack.UTF8)
+      val input2 =
+        new SplitMessageBufferInput(
+          Array(
+            Array[Byte](MessagePack.Code.STR32),
+            Array[Byte](0x00),
+            Array[Byte](0x00, 0x00),
+            Array[Byte](0x05), // STR32 length at the boundary
+            "hello".getBytes(MessagePack.UTF8)
+          )
         )
-      )
       readTest(input2)
     }
   }
-}
+
+end MessageUnpackerTest
diff --git a/msgpack-core/src/test/scala/org/msgpack/core/StringLimitTest.scala b/msgpack-core/src/test/scala/org/msgpack/core/StringLimitTest.scala
new file mode 100644
index 000000000..c54ce6329
--- /dev/null
+++ b/msgpack-core/src/test/scala/org/msgpack/core/StringLimitTest.scala
@@ -0,0 +1,38 @@
+package org.msgpack.core
+
+import org.msgpack.core.MessagePack.UnpackerConfig
+import org.msgpack.value.Variable
+import wvlet.airspec.AirSpec
+
+class StringLimitTest extends AirSpec:
+
+  test("throws an exception when the string size exceeds a limit") {
+    val customLimit = 100
+    val packer      = MessagePack.newDefaultBufferPacker()
+    packer.packString("a" * (customLimit + 1))
+    val msgpack = packer.toByteArray
+
+    test("unpackString") {
+      val unpacker = new UnpackerConfig().withStringSizeLimit(customLimit).newUnpacker(msgpack)
+      intercept[MessageSizeException] {
+        unpacker.unpackString()
+      }
+    }
+
+    test("unpackValue") {
+      val unpacker = new UnpackerConfig().withStringSizeLimit(customLimit).newUnpacker(msgpack)
+      intercept[MessageSizeException] {
+        unpacker.unpackValue()
+      }
+    }
+
+    test("unpackValue(var)") {
+      val unpacker = new UnpackerConfig().withStringSizeLimit(customLimit).newUnpacker(msgpack)
+      intercept[MessageSizeException] {
+        val v = new Variable()
+        unpacker.unpackValue(v)
+      }
+    }
+  }
+
+end StringLimitTest
diff --git a/msgpack-core/src/test/scala/org/msgpack/core/buffer/ByteStringTest.scala b/msgpack-core/src/test/scala/org/msgpack/core/buffer/ByteStringTest.scala
index 42872fc44..06d363fd5 100644
--- a/msgpack-core/src/test/scala/org/msgpack/core/buffer/ByteStringTest.scala
+++ b/msgpack-core/src/test/scala/org/msgpack/core/buffer/ByteStringTest.scala
@@ -20,28 +20,26 @@ import org.msgpack.core.MessagePack
 import org.msgpack.core.MessagePackSpec.createMessagePackData
 import wvlet.airspec.AirSpec
 
-class ByteStringTest extends AirSpec {
+class ByteStringTest extends AirSpec:
 
   private val unpackedString = "foo"
   private val byteString     = ByteString(createMessagePackData(_.packString(unpackedString)))
 
-  private def unpackString(messageBuffer: MessageBuffer) = {
-    val input = new MessageBufferInput {
+  private def unpackString(messageBuffer: MessageBuffer) =
+    val input =
+      new MessageBufferInput:
 
-      private var isRead = false
+        private var isRead = false
 
-      override def next(): MessageBuffer =
-        if (isRead) {
-          null
-        } else {
-          isRead = true
-          messageBuffer
-        }
-      override def close(): Unit = {}
-    }
+        override def next(): MessageBuffer =
+          if isRead then
+            null
+          else
+            isRead = true
+            messageBuffer
+        override def close(): Unit = {}
 
     MessagePack.newDefaultUnpacker(input).unpackString()
-  }
 
   test("Unpacking a ByteString's ByteBuffer") {
     test("fail with a regular MessageBuffer") {
@@ -53,4 +51,5 @@ class ByteStringTest extends AirSpec {
       }
     }
   }
-}
+
+end ByteStringTest
diff --git a/msgpack-core/src/test/scala/org/msgpack/core/buffer/DirectBufferAccessTest.scala b/msgpack-core/src/test/scala/org/msgpack/core/buffer/DirectBufferAccessTest.scala
new file mode 100644
index 000000000..5bb4b49d1
--- /dev/null
+++ b/msgpack-core/src/test/scala/org/msgpack/core/buffer/DirectBufferAccessTest.scala
@@ -0,0 +1,28 @@
+//
+// MessagePack for Java
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+package org.msgpack.core.buffer
+
+import wvlet.airspec.AirSpec
+
+import java.nio.ByteBuffer
+
+class DirectBufferAccessTest extends AirSpec:
+
+  test("instantiate DirectBufferAccess") {
+    val bb   = ByteBuffer.allocateDirect(1)
+    val addr = DirectBufferAccess.getAddress(bb)
+
+  }
diff --git a/msgpack-core/src/test/scala/org/msgpack/core/buffer/MessageBufferInputTest.scala b/msgpack-core/src/test/scala/org/msgpack/core/buffer/MessageBufferInputTest.scala
index dd1cdb974..5e6c1f96d 100644
--- a/msgpack-core/src/test/scala/org/msgpack/core/buffer/MessageBufferInputTest.scala
+++ b/msgpack-core/src/test/scala/org/msgpack/core/buffer/MessageBufferInputTest.scala
@@ -19,7 +19,7 @@ import org.msgpack.core.MessagePack
 import wvlet.airspec.AirSpec
 import wvlet.log.io.IOUtil.withResource
 
-import java.io._
+import java.io.*
 import java.net.InetSocketAddress
 import java.nio.ByteBuffer
 import java.nio.channels.{ServerSocketChannel, SocketChannel}
@@ -27,63 +27,49 @@ import java.util.concurrent.{Callable, Executors, TimeUnit}
 import java.util.zip.{GZIPInputStream, GZIPOutputStream}
 import scala.util.Random
 
-class MessageBufferInputTest extends AirSpec {
+class MessageBufferInputTest extends AirSpec:
 
-  private val targetInputSize =
-    Seq(0, 10, 500, 1000, 2000, 4000, 8000, 10000, 30000, 50000, 100000)
+  private val targetInputSize = Seq(0, 10, 500, 1000, 2000, 4000, 8000, 10000, 30000, 50000, 100000)
 
-  private def testData(size: Int): Array[Byte] = {
-    //debug(s"test data size: ${size}")
+  private def testData(size: Int): Array[Byte] =
+    // debug(s"test data size: ${size}")
     val b = new Array[Byte](size)
     Random.nextBytes(b)
     b
-  }
 
-  private def testDataSet: Seq[Array[Byte]] = {
-    targetInputSize.map(testData)
-  }
+  private def testDataSet: Seq[Array[Byte]] = targetInputSize.map(testData)
 
-  private def runTest(factory: Array[Byte] => MessageBufferInput): Unit = {
-    for (b <- testDataSet) {
+  private def runTest(factory: Array[Byte] => MessageBufferInput): Unit =
+    for b <- testDataSet do
       checkInputData(b, factory(b))
-    }
-  }
 
-  implicit class InputData(b: Array[Byte]) {
-    def compress = {
+  implicit class InputData(b: Array[Byte]):
+    def compress =
       val compressed = new ByteArrayOutputStream()
       val out        = new GZIPOutputStream(compressed)
       out.write(b)
       out.close()
       compressed.toByteArray
-    }
 
-    def toByteBuffer = {
-      ByteBuffer.wrap(b)
-    }
+    def toByteBuffer = ByteBuffer.wrap(b)
 
-    def saveToTmpFile: File = {
-      val tmp = File
-        .createTempFile("testbuf", ".dat", new File("target"))
+    def saveToTmpFile: File =
+      val tmp = File.createTempFile("testbuf", ".dat", new File("target"))
       tmp.getParentFile.mkdirs()
       tmp.deleteOnExit()
       withResource(new FileOutputStream(tmp)) { out =>
         out.write(b)
       }
       tmp
-    }
-  }
 
-  private def checkInputData(inputData: Array[Byte], in: MessageBufferInput): Unit = {
+  private def checkInputData(inputData: Array[Byte], in: MessageBufferInput): Unit =
     test(s"When input data size = ${inputData.length}") {
       var cursor = 0
-      for (m <- Iterator.continually(in.next).takeWhile(_ != null)) {
+      for m <- Iterator.continually(in.next).takeWhile(_ != null) do
         m.toByteArray() shouldBe inputData.slice(cursor, cursor + m.size())
         cursor += m.size()
-      }
       cursor shouldBe inputData.length
     }
-  }
 
   test("MessageBufferInput") {
     test("support byte arrays") {
@@ -95,46 +81,40 @@ class MessageBufferInputTest extends AirSpec {
     }
 
     test("support InputStreams") {
-      runTest(b => new InputStreamBufferInput(new GZIPInputStream(new ByteArrayInputStream(b.compress))))
+      runTest(b =>
+        new InputStreamBufferInput(new GZIPInputStream(new ByteArrayInputStream(b.compress)))
+      )
     }
 
     test("support file input channel") {
       runTest { b =>
         val tmp = b.saveToTmpFile
-        try {
-          InputStreamBufferInput
-            .newBufferInput(new FileInputStream(tmp))
-        } finally {
-          tmp.delete()
-        }
+        try InputStreamBufferInput.newBufferInput(new FileInputStream(tmp))
+        finally tmp.delete()
       }
     }
   }
 
-  private def createTempFile = {
+  private def createTempFile =
     val f = File.createTempFile("msgpackTest", "msgpack")
     f.deleteOnExit
     f
-  }
 
-  private def createTempFileWithInputStream = {
+  private def createTempFileWithInputStream =
     val f   = createTempFile
     val out = new FileOutputStream(f)
     MessagePack.newDefaultPacker(out).packInt(42).close
     val in = new FileInputStream(f)
     (f, in)
-  }
 
-  private def createTempFileWithChannel = {
+  private def createTempFileWithChannel =
     val (f, in) = createTempFileWithInputStream
     val ch      = in.getChannel
     (f, ch)
-  }
 
-  private def readInt(buf: MessageBufferInput): Int = {
+  private def readInt(buf: MessageBufferInput): Int =
     val unpacker = MessagePack.newDefaultUnpacker(buf)
     unpacker.unpackInt
-  }
 
   test("InputStreamBufferInput") {
     test("reset buffer") {
@@ -186,42 +166,42 @@ class MessageBufferInputTest extends AirSpec {
     }
 
     test("unpack without blocking") {
-      val server =
-        ServerSocketChannel.open.bind(new InetSocketAddress("localhost", 0))
+      val server          = ServerSocketChannel.open.bind(new InetSocketAddress("localhost", 0))
       val executorService = Executors.newCachedThreadPool
 
-      try {
-        executorService.execute(new Runnable {
-          override def run: Unit = {
-            val server_ch = server.accept
-            val packer    = MessagePack.newDefaultPacker(server_ch)
-            packer.packString("0123456789")
-            packer.flush
-            // Keep the connection open
-            while (!executorService.isShutdown) {
-              TimeUnit.SECONDS.sleep(1)
-            }
-            packer.close
-          }
-        })
-
-        val future = executorService.submit(new Callable[String] {
-          override def call: String = {
-            val conn_ch  = SocketChannel.open(new InetSocketAddress("localhost", server.socket.getLocalPort))
-            val unpacker = MessagePack.newDefaultUnpacker(conn_ch)
-            val s        = unpacker.unpackString
-            unpacker.close
-            s
-          }
-        })
+      try
+        executorService.execute(
+          new Runnable:
+            override def run: Unit =
+              val server_ch = server.accept
+              val packer    = MessagePack.newDefaultPacker(server_ch)
+              packer.packString("0123456789")
+              packer.flush
+              // Keep the connection open
+              while !executorService.isShutdown do
+                TimeUnit.SECONDS.sleep(1)
+              packer.close
+        )
+
+        val future = executorService.submit(
+          new Callable[String]:
+            override def call: String =
+              val conn_ch = SocketChannel.open(
+                new InetSocketAddress("localhost", server.socket.getLocalPort)
+              )
+              val unpacker = MessagePack.newDefaultUnpacker(conn_ch)
+              val s        = unpacker.unpackString
+              unpacker.close
+              s
+        )
 
         future.get(5, TimeUnit.SECONDS) shouldBe "0123456789"
-      } finally {
+      finally
         executorService.shutdown
-        if (!executorService.awaitTermination(5, TimeUnit.SECONDS)) {
+        if !executorService.awaitTermination(5, TimeUnit.SECONDS) then
           executorService.shutdownNow
-        }
-      }
+      end try
     }
   }
-}
+
+end MessageBufferInputTest
diff --git a/msgpack-core/src/test/scala/org/msgpack/core/buffer/MessageBufferOutputTest.scala b/msgpack-core/src/test/scala/org/msgpack/core/buffer/MessageBufferOutputTest.scala
index ea9cde57e..5f6e9b7a3 100644
--- a/msgpack-core/src/test/scala/org/msgpack/core/buffer/MessageBufferOutputTest.scala
+++ b/msgpack-core/src/test/scala/org/msgpack/core/buffer/MessageBufferOutputTest.scala
@@ -17,34 +17,30 @@ package org.msgpack.core.buffer
 
 import wvlet.airspec.AirSpec
 
-import java.io._
+import java.io.*
 
-class MessageBufferOutputTest extends AirSpec {
+class MessageBufferOutputTest extends AirSpec:
 
-  private def createTempFile = {
+  private def createTempFile =
     val f = File.createTempFile("msgpackTest", "msgpack")
     f.deleteOnExit
     f
-  }
 
-  private def createTempFileWithOutputStream = {
+  private def createTempFileWithOutputStream =
     val f   = createTempFile
     val out = new FileOutputStream(f)
     (f, out)
-  }
 
-  private def createTempFileWithChannel = {
+  private def createTempFileWithChannel =
     val (f, out) = createTempFileWithOutputStream
     val ch       = out.getChannel
     (f, ch)
-  }
 
-  private def writeIntToBuf(buf: MessageBufferOutput) = {
+  private def writeIntToBuf(buf: MessageBufferOutput) =
     val mb0 = buf.next(8)
     mb0.putInt(0, 42)
     buf.writeBuffer(4)
     buf.close
-  }
 
   test("OutputStreamBufferOutput") {
     test("reset buffer") {
@@ -73,4 +69,5 @@ class MessageBufferOutputTest extends AirSpec {
       f1.length.toInt > 0 shouldBe true
     }
   }
-}
+
+end MessageBufferOutputTest
diff --git a/msgpack-core/src/test/scala/org/msgpack/core/buffer/MessageBufferTest.scala b/msgpack-core/src/test/scala/org/msgpack/core/buffer/MessageBufferTest.scala
index 4de059951..36940473d 100644
--- a/msgpack-core/src/test/scala/org/msgpack/core/buffer/MessageBufferTest.scala
+++ b/msgpack-core/src/test/scala/org/msgpack/core/buffer/MessageBufferTest.scala
@@ -24,7 +24,7 @@ import scala.util.Random
 /**
   * Created on 2014/05/01.
   */
-class MessageBufferTest extends AirSpec with Benchmark {
+class MessageBufferTest extends AirSpec with Benchmark:
 
   private val universal = MessageBuffer.allocate(0).isInstanceOf[MessageBufferU]
 
@@ -55,97 +55,87 @@ class MessageBufferTest extends AirSpec with Benchmark {
 
     val ub = MessageBuffer.allocate(M)
     val ud =
-      if (universal) MessageBuffer.wrap(ByteBuffer.allocate(M))
-      else MessageBuffer.wrap(ByteBuffer.allocateDirect(M))
+      if universal then
+        MessageBuffer.wrap(ByteBuffer.allocate(M))
+      else
+        MessageBuffer.wrap(ByteBuffer.allocateDirect(M))
     val hb = ByteBuffer.allocate(M)
     val db = ByteBuffer.allocateDirect(M)
 
-    def bench(f: Int => Unit): Unit = {
+    def bench(f: Int => Unit): Unit =
       var i = 0
-      while (i < N) {
+      while i < N do
         f((i * 4) % M)
         i += 1
-      }
-    }
 
     val r  = new Random(0)
     val rs = new Array[Int](N)
     (0 until N).map(i => rs(i) = r.nextInt(N))
-    def randomBench(f: Int => Unit): Unit = {
+    def randomBench(f: Int => Unit): Unit =
       var i = 0
-      while (i < N) {
+      while i < N do
         f((rs(i) * 4) % M)
         i += 1
-      }
-    }
 
     val rep = 3
     info(f"Reading buffers (of size:${M}%,d) ${N}%,d x $rep times")
     time("sequential getInt", repeat = rep) {
       block("unsafe array") {
         var i = 0
-        while (i < N) {
+        while i < N do
           ub.getInt((i * 4) % M)
           i += 1
-        }
       }
 
       block("unsafe direct") {
         var i = 0
-        while (i < N) {
+        while i < N do
           ud.getInt((i * 4) % M)
           i += 1
-        }
       }
 
       block("allocate") {
         var i = 0
-        while (i < N) {
+        while i < N do
           hb.getInt((i * 4) % M)
           i += 1
-        }
       }
 
       block("allocateDirect") {
         var i = 0
-        while (i < N) {
+        while i < N do
           db.getInt((i * 4) % M)
           i += 1
-        }
       }
     }
 
     time("random getInt", repeat = rep) {
       block("unsafe array") {
         var i = 0
-        while (i < N) {
+        while i < N do
           ub.getInt((rs(i) * 4) % M)
           i += 1
-        }
       }
 
       block("unsafe direct") {
         var i = 0
-        while (i < N) {
+        while i < N do
           ud.getInt((rs(i) * 4) % M)
           i += 1
-        }
       }
 
       block("allocate") {
         var i = 0
-        while (i < N) {
+        while i < N do
           hb.getInt((rs(i) * 4) % M)
           i += 1
-        }
       }
 
       block("allocateDirect") {
         var i = 0
-        while (i < N) {
+        while i < N do
           db.getInt((rs(i) * 4) % M)
           i += 1
-        }
       }
     }
   }
@@ -153,20 +143,21 @@ class MessageBufferTest extends AirSpec with Benchmark {
   private val builder = Seq.newBuilder[MessageBuffer]
   builder += MessageBuffer.allocate(10)
   builder += MessageBuffer.wrap(ByteBuffer.allocate(10))
-  if (!universal) builder += MessageBuffer.wrap(ByteBuffer.allocateDirect(10))
+  if !universal then
+    builder += MessageBuffer.wrap(ByteBuffer.allocateDirect(10))
+
   private val buffers = builder.result()
 
   test("convert to ByteBuffer") {
-    for (t <- buffers) {
+    for t <- buffers do
       val bb = t.sliceAsByteBuffer
       bb.position() shouldBe 0
       bb.limit() shouldBe 10
       bb.capacity shouldBe 10
-    }
   }
 
   test("put ByteBuffer on itself") {
-    for (t <- buffers) {
+    for t <- buffers do
       val b        = Array[Byte](0x02, 0x03)
       val srcArray = ByteBuffer.wrap(b)
       val srcHeap  = ByteBuffer.allocate(b.length)
@@ -174,7 +165,7 @@ class MessageBufferTest extends AirSpec with Benchmark {
       val srcOffHeap = ByteBuffer.allocateDirect(b.length)
       srcOffHeap.put(b).flip
 
-      for (src <- Seq(srcArray, srcHeap, srcOffHeap)) {
+      for src <- Seq(srcArray, srcHeap, srcOffHeap) do
         // Write header bytes
         val header = Array[Byte](0x00, 0x01)
         t.putBytes(0, header, 0, header.length)
@@ -185,12 +176,10 @@ class MessageBufferTest extends AirSpec with Benchmark {
         t.getByte(1) shouldBe 0x01
         t.getByte(2) shouldBe 0x02
         t.getByte(3) shouldBe 0x03
-      }
-    }
   }
 
   test("put MessageBuffer on itself") {
-    for (t <- buffers) {
+    for t <- buffers do
       val b        = Array[Byte](0x02, 0x03)
       val srcArray = ByteBuffer.wrap(b)
       val srcHeap  = ByteBuffer.allocate(b.length)
@@ -199,9 +188,10 @@ class MessageBufferTest extends AirSpec with Benchmark {
       srcOffHeap.put(b).flip
       val builder = Seq.newBuilder[ByteBuffer]
       builder ++= Seq(srcArray, srcHeap)
-      if (!universal) builder += srcOffHeap
+      if !universal then
+        builder += srcOffHeap
 
-      for (src <- builder.result().map(d => MessageBuffer.wrap(d))) {
+      for src <- builder.result().map(d => MessageBuffer.wrap(d)) do
         // Write header bytes
         val header = Array[Byte](0x00, 0x01)
         t.putBytes(0, header, 0, header.length)
@@ -212,23 +202,18 @@ class MessageBufferTest extends AirSpec with Benchmark {
         t.getByte(1) shouldBe 0x01
         t.getByte(2) shouldBe 0x02
         t.getByte(3) shouldBe 0x03
-      }
-    }
   }
 
   test("copy sliced buffer") {
-    def prepareBytes: Array[Byte] = {
-      Array[Byte](0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07)
-    }
+    def prepareBytes: Array[Byte] = Array[Byte](0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07)
 
-    def prepareDirectBuffer: ByteBuffer = {
+    def prepareDirectBuffer: ByteBuffer =
       val directBuffer = ByteBuffer.allocateDirect(prepareBytes.length)
       directBuffer.put(prepareBytes)
       directBuffer.flip
       directBuffer
-    }
 
-    def checkSliceAndCopyTo(srcBuffer: MessageBuffer, dstBuffer: MessageBuffer) = {
+    def checkSliceAndCopyTo(srcBuffer: MessageBuffer, dstBuffer: MessageBuffer) =
       val sliced = srcBuffer.slice(2, 5)
 
       sliced.size() shouldBe 5
@@ -248,12 +233,17 @@ class MessageBufferTest extends AirSpec with Benchmark {
       dstBuffer.getByte(5) shouldBe 0x05
       dstBuffer.getByte(6) shouldBe 0x06
       dstBuffer.getByte(7) shouldBe 0x07
-    }
 
     checkSliceAndCopyTo(MessageBuffer.wrap(prepareBytes), MessageBuffer.wrap(prepareBytes))
-    checkSliceAndCopyTo(MessageBuffer.wrap(ByteBuffer.wrap(prepareBytes)), MessageBuffer.wrap(ByteBuffer.wrap(prepareBytes)))
-    if (!universal) {
-      checkSliceAndCopyTo(MessageBuffer.wrap(prepareDirectBuffer), MessageBuffer.wrap(prepareDirectBuffer))
-    }
+    checkSliceAndCopyTo(
+      MessageBuffer.wrap(ByteBuffer.wrap(prepareBytes)),
+      MessageBuffer.wrap(ByteBuffer.wrap(prepareBytes))
+    )
+    if !universal then
+      checkSliceAndCopyTo(
+        MessageBuffer.wrap(prepareDirectBuffer),
+        MessageBuffer.wrap(prepareDirectBuffer)
+      )
   }
-}
+
+end MessageBufferTest
diff --git a/msgpack-core/src/test/scala/org/msgpack/core/example/MessagePackExampleTest.scala b/msgpack-core/src/test/scala/org/msgpack/core/example/MessagePackExampleTest.scala
index 99876275d..1a1a3a3ca 100644
--- a/msgpack-core/src/test/scala/org/msgpack/core/example/MessagePackExampleTest.scala
+++ b/msgpack-core/src/test/scala/org/msgpack/core/example/MessagePackExampleTest.scala
@@ -19,7 +19,7 @@ import wvlet.airspec.AirSpec
 
 /**
   */
-class MessagePackExampleTest extends AirSpec {
+class MessagePackExampleTest extends AirSpec:
 
   test("example") {
 
@@ -39,4 +39,3 @@ class MessagePackExampleTest extends AirSpec {
       MessagePackExample.configuration();
     }
   }
-}
diff --git a/msgpack-core/src/test/scala/org/msgpack/value/RawStringValueImplTest.scala b/msgpack-core/src/test/scala/org/msgpack/value/RawStringValueImplTest.scala
index fb340553c..73e1edc56 100644
--- a/msgpack-core/src/test/scala/org/msgpack/value/RawStringValueImplTest.scala
+++ b/msgpack-core/src/test/scala/org/msgpack/value/RawStringValueImplTest.scala
@@ -17,7 +17,7 @@ package org.msgpack.value
 
 import wvlet.airspec.AirSpec
 
-class RawStringValueImplTest extends AirSpec {
+class RawStringValueImplTest extends AirSpec:
 
   test("return the same hash code if they are equal") {
     val str = "a"
@@ -29,4 +29,3 @@ class RawStringValueImplTest extends AirSpec {
     a2 shouldBe a1
     a2.hashCode shouldBe a1.hashCode
   }
-}
diff --git a/msgpack-core/src/test/scala/org/msgpack/value/ValueFactoryTest.scala b/msgpack-core/src/test/scala/org/msgpack/value/ValueFactoryTest.scala
index 3fe2a07f8..623ca36da 100644
--- a/msgpack-core/src/test/scala/org/msgpack/value/ValueFactoryTest.scala
+++ b/msgpack-core/src/test/scala/org/msgpack/value/ValueFactoryTest.scala
@@ -21,7 +21,7 @@ import wvlet.airspec.spi.PropertyCheck
 
 /**
   */
-class ValueFactoryTest extends AirSpec with PropertyCheck {
+class ValueFactoryTest extends AirSpec with PropertyCheck:
 
   private def isValid(
       v: Value,
@@ -38,7 +38,7 @@ class ValueFactoryTest extends AirSpec with PropertyCheck {
       isRaw: Boolean = false,
       isNumber: Boolean = false,
       isTimestamp: Boolean = false
-  ): Boolean = {
+  ): Boolean =
     v.isNilValue shouldBe isNil
     v.isBooleanValue shouldBe isBoolean
     v.isIntegerValue shouldBe isInteger
@@ -52,7 +52,6 @@ class ValueFactoryTest extends AirSpec with PropertyCheck {
     v.isNumberValue shouldBe isNumber
     v.isTimestampValue shouldBe isTimestamp
     true
-  }
 
   test("ValueFactory") {
     test("nil") {
@@ -67,24 +66,44 @@ class ValueFactoryTest extends AirSpec with PropertyCheck {
 
     test("int") {
       forAll { (v: Int) =>
-        isValid(ValueFactory.newInteger(v), expected = ValueType.INTEGER, isInteger = true, isNumber = true)
+        isValid(
+          ValueFactory.newInteger(v),
+          expected = ValueType.INTEGER,
+          isInteger = true,
+          isNumber = true
+        )
       }
     }
 
     test("float") {
       forAll { (v: Float) =>
-        isValid(ValueFactory.newFloat(v), expected = ValueType.FLOAT, isFloat = true, isNumber = true)
+        isValid(
+          ValueFactory.newFloat(v),
+          expected = ValueType.FLOAT,
+          isFloat = true,
+          isNumber = true
+        )
       }
     }
     test("string") {
       forAll { (v: String) =>
-        isValid(ValueFactory.newString(v), expected = ValueType.STRING, isString = true, isRaw = true)
+        isValid(
+          ValueFactory.newString(v),
+          expected = ValueType.STRING,
+          isString = true,
+          isRaw = true
+        )
       }
     }
 
     test("array") {
       forAll { (v: Array[Byte]) =>
-        isValid(ValueFactory.newBinary(v), expected = ValueType.BINARY, isBinary = true, isRaw = true)
+        isValid(
+          ValueFactory.newBinary(v),
+          expected = ValueType.BINARY,
+          isBinary = true,
+          isRaw = true
+        )
       }
     }
 
@@ -98,13 +117,23 @@ class ValueFactoryTest extends AirSpec with PropertyCheck {
 
     test("ext") {
       forAll { (v: Array[Byte]) =>
-        isValid(ValueFactory.newExtension(0, v), expected = ValueType.EXTENSION, isExtension = true, isRaw = false)
+        isValid(
+          ValueFactory.newExtension(0, v),
+          expected = ValueType.EXTENSION,
+          isExtension = true,
+          isRaw = false
+        )
       }
     }
 
     test("timestamp") {
       forAll { (millis: Long) =>
-        isValid(ValueFactory.newTimestamp(millis), expected = ValueType.EXTENSION, isExtension = true, isTimestamp = true)
+        isValid(
+          ValueFactory.newTimestamp(millis),
+          expected = ValueType.EXTENSION,
+          isExtension = true,
+          isTimestamp = true
+        )
       }
     }
 
@@ -112,8 +141,14 @@ class ValueFactoryTest extends AirSpec with PropertyCheck {
       val posLong = Gen.chooseNum[Long](-31557014167219200L, 31556889864403199L)
       val posInt  = Gen.chooseNum(0, 1000000000 - 1) // NANOS_PER_SECOND
       forAll(posLong, posInt) { (sec: Long, nano: Int) =>
-        isValid(ValueFactory.newTimestamp(sec, nano), expected = ValueType.EXTENSION, isExtension = true, isTimestamp = true)
+        isValid(
+          ValueFactory.newTimestamp(sec, nano),
+          expected = ValueType.EXTENSION,
+          isExtension = true,
+          isTimestamp = true
+        )
       }
     }
   }
-}
+
+end ValueFactoryTest
diff --git a/msgpack-core/src/test/scala/org/msgpack/value/ValueTest.scala b/msgpack-core/src/test/scala/org/msgpack/value/ValueTest.scala
index 83cbde6bf..76e2ed27a 100644
--- a/msgpack-core/src/test/scala/org/msgpack/value/ValueTest.scala
+++ b/msgpack-core/src/test/scala/org/msgpack/value/ValueTest.scala
@@ -18,14 +18,17 @@ package org.msgpack.value
 import org.msgpack.core.MessagePackSpec.createMessagePackData
 
 import java.math.BigInteger
-import org.msgpack.core._
+import org.msgpack.core.*
 import org.scalacheck.Prop.propBoolean
 import wvlet.airframe.json.JSON
 import wvlet.airspec.AirSpec
 import wvlet.airspec.spi.PropertyCheck
 
-class ValueTest extends AirSpec with PropertyCheck {
-  private def checkSuccinctType(pack: MessagePacker => Unit, expectedAtMost: MessageFormat): Boolean = {
+class ValueTest extends AirSpec with PropertyCheck:
+  private def checkSuccinctType(
+      pack: MessagePacker => Unit,
+      expectedAtMost: MessageFormat
+  ): Boolean =
     val b  = createMessagePackData(pack)
     val v1 = MessagePack.newDefaultUnpacker(b).unpackValue()
     val mf = v1.asIntegerValue().mostSuccinctMessageFormat()
@@ -39,7 +42,6 @@ class ValueTest extends AirSpec with PropertyCheck {
     mf2.ordinal() <= expectedAtMost.ordinal() shouldBe true
 
     true
-  }
 
   test("Value") {
     test("tell most succinct integer type") {
@@ -61,14 +63,17 @@ class ValueTest extends AirSpec with PropertyCheck {
       forAll { (v: Long) =>
         v > 0 ==> {
           // Create value between 2^63-1 < v <= 2^64-1
-          checkSuccinctType(_.packBigInteger(BigInteger.valueOf(Long.MaxValue).add(BigInteger.valueOf(v))), MessageFormat.UINT64)
+          checkSuccinctType(
+            _.packBigInteger(BigInteger.valueOf(Long.MaxValue).add(BigInteger.valueOf(v))),
+            MessageFormat.UINT64
+          )
         }
       }
     }
 
     test("produce json strings") {
 
-      import ValueFactory._
+      import ValueFactory.*
 
       newNil().toJson shouldBe "null"
       newNil().toString shouldBe "null"
@@ -88,7 +93,8 @@ class ValueTest extends AirSpec with PropertyCheck {
 
       newArray(newInteger(0), newString("hello")).toJson shouldBe "[0,\"hello\"]"
       newArray(newInteger(0), newString("hello")).toString shouldBe "[0,\"hello\"]"
-      newArray(newArray(newString("Apple"), newFloat(0.2)), newNil()).toJson shouldBe """[["Apple",0.2],null]"""
+      newArray(newArray(newString("Apple"), newFloat(0.2)), newNil()).toJson shouldBe
+        """[["Apple",0.2],null]"""
 
       // Map value
       val m = newMapBuilder()
@@ -112,7 +118,7 @@ class ValueTest extends AirSpec with PropertyCheck {
     }
 
     test("check appropriate range for integers") {
-      import ValueFactory._
+      import ValueFactory.*
       import java.lang.Byte
       import java.lang.Short
 
@@ -142,4 +148,5 @@ class ValueTest extends AirSpec with PropertyCheck {
       }
     }
   }
-}
+
+end ValueTest
diff --git a/msgpack-core/src/test/scala/org/msgpack/value/ValueTypeTest.scala b/msgpack-core/src/test/scala/org/msgpack/value/ValueTypeTest.scala
index e8b04d5f6..7b992f28b 100644
--- a/msgpack-core/src/test/scala/org/msgpack/value/ValueTypeTest.scala
+++ b/msgpack-core/src/test/scala/org/msgpack/value/ValueTypeTest.scala
@@ -15,71 +15,59 @@
 //
 package org.msgpack.value
 
-import org.msgpack.core.MessagePack.Code._
+import org.msgpack.core.MessagePack.Code.*
 import org.msgpack.core.{MessageFormat, MessageFormatException}
 import wvlet.airspec.AirSpec
 
 /**
   * Created on 2014/05/06.
   */
-class ValueTypeTest extends AirSpec {
+class ValueTypeTest extends AirSpec:
 
   test("lookup ValueType from a byte value") {
-    def check(b: Byte, tpe: ValueType): Unit = {
-      MessageFormat.valueOf(b).getValueType shouldBe tpe
-    }
+    def check(b: Byte, tpe: ValueType): Unit = MessageFormat.valueOf(b).getValueType shouldBe tpe
 
-    for (i <- 0 until 0x7f) {
+    for i <- 0 until 0x7f do
       check(i.toByte, ValueType.INTEGER)
-    }
 
-    for (i <- 0x80 until 0x8f) {
+    for i <- 0x80 until 0x8f do
       check(i.toByte, ValueType.MAP)
-    }
 
-    for (i <- 0x90 until 0x9f) {
+    for i <- 0x90 until 0x9f do
       check(i.toByte, ValueType.ARRAY)
-    }
 
     check(NIL, ValueType.NIL)
 
-    try {
+    try
       MessageFormat.valueOf(NEVER_USED).getValueType
       fail("NEVER_USED type should not have ValueType")
-    } catch {
+    catch
       case e: MessageFormatException =>
       // OK
-    }
 
     check(TRUE, ValueType.BOOLEAN)
     check(FALSE, ValueType.BOOLEAN)
 
-    for (t <- Seq(BIN8, BIN16, BIN32)) {
+    for t <- Seq(BIN8, BIN16, BIN32) do
       check(t, ValueType.BINARY)
-    }
 
-    for (t <- Seq(FIXEXT1, FIXEXT2, FIXEXT4, FIXEXT8, FIXEXT16, EXT8, EXT16, EXT32)) {
+    for t <- Seq(FIXEXT1, FIXEXT2, FIXEXT4, FIXEXT8, FIXEXT16, EXT8, EXT16, EXT32) do
       check(t, ValueType.EXTENSION)
-    }
 
-    for (t <- Seq(INT8, INT16, INT32, INT64, UINT8, UINT16, UINT32, UINT64)) {
+    for t <- Seq(INT8, INT16, INT32, INT64, UINT8, UINT16, UINT32, UINT64) do
       check(t, ValueType.INTEGER)
-    }
 
-    for (t <- Seq(STR8, STR16, STR32)) {
+    for t <- Seq(STR8, STR16, STR32) do
       check(t, ValueType.STRING)
-    }
 
-    for (t <- Seq(FLOAT32, FLOAT64)) {
+    for t <- Seq(FLOAT32, FLOAT64) do
       check(t, ValueType.FLOAT)
-    }
 
-    for (t <- Seq(ARRAY16, ARRAY32)) {
+    for t <- Seq(ARRAY16, ARRAY32) do
       check(t, ValueType.ARRAY)
-    }
 
-    for (i <- 0xe0 until 0xff) {
+    for i <- 0xe0 until 0xff do
       check(i.toByte, ValueType.INTEGER)
-    }
   }
-}
+
+end ValueTypeTest
diff --git a/msgpack-core/src/test/scala/org/msgpack/value/VariableTest.scala b/msgpack-core/src/test/scala/org/msgpack/value/VariableTest.scala
index 5d97d8712..2f3cbf9c8 100644
--- a/msgpack-core/src/test/scala/org/msgpack/value/VariableTest.scala
+++ b/msgpack-core/src/test/scala/org/msgpack/value/VariableTest.scala
@@ -21,12 +21,12 @@ import wvlet.airspec.spi.PropertyCheck
 
 import java.time.Instant
 import java.util
-import scala.jdk.CollectionConverters._
+import scala.jdk.CollectionConverters.*
 
 /**
   */
-class VariableTest extends AirSpec with PropertyCheck {
-  private def check(pack: MessagePacker => Unit, checker: Variable => Unit): Unit = {
+class VariableTest extends AirSpec with PropertyCheck:
+  private def check(pack: MessagePacker => Unit, checker: Variable => Unit): Unit =
     val packer = MessagePack.newDefaultBufferPacker()
     pack(packer)
     val msgpack = packer.toByteArray
@@ -36,12 +36,11 @@ class VariableTest extends AirSpec with PropertyCheck {
     unpacker.unpackValue(v)
     checker(v)
     unpacker.close()
-  }
 
   /**
     * Test Value -> MsgPack -> Value
     */
-  private def roundTrip(v: Value): Unit = {
+  private def roundTrip(v: Value): Unit =
     val packer = MessagePack.newDefaultBufferPacker()
     v.writeTo(packer)
     val msgpack  = packer.toByteArray
@@ -50,7 +49,6 @@ class VariableTest extends AirSpec with PropertyCheck {
     unpacker.close()
     v shouldBe v1
     v.immutableValue() shouldBe v1
-  }
 
   private def validateValue[V <: Value](
       v: V,
@@ -64,7 +62,7 @@ class VariableTest extends AirSpec with PropertyCheck {
       asMap: Boolean = false,
       asExtension: Boolean = false,
       asTimestamp: Boolean = false
-  ): V = {
+  ): V =
     v.isNilValue shouldBe asNil
     v.isBooleanValue shouldBe asBoolean
     v.isIntegerValue shouldBe asInteger
@@ -78,203 +76,200 @@ class VariableTest extends AirSpec with PropertyCheck {
     v.isExtensionValue shouldBe asExtension | asTimestamp
     v.isTimestampValue shouldBe asTimestamp
 
-    if (asNil) {
+    if asNil then
       v.getValueType shouldBe ValueType.NIL
       roundTrip(v)
-    } else {
+    else
       intercept[MessageTypeCastException] {
         v.asNilValue()
       }
-    }
 
-    if (asBoolean) {
+    if asBoolean then
       v.getValueType shouldBe ValueType.BOOLEAN
       roundTrip(v)
-    } else {
+    else
       intercept[MessageTypeCastException] {
         v.asBooleanValue()
       }
-    }
 
-    if (asInteger) {
+    if asInteger then
       v.getValueType shouldBe ValueType.INTEGER
       roundTrip(v)
-    } else {
+    else
       intercept[MessageTypeCastException] {
         v.asIntegerValue()
       }
-    }
 
-    if (asFloat) {
+    if asFloat then
       v.getValueType shouldBe ValueType.FLOAT
       roundTrip(v)
-    } else {
+    else
       intercept[MessageTypeCastException] {
         v.asFloatValue()
       }
-    }
 
-    if (asBinary | asString) {
+    if asBinary | asString then
       v.asRawValue()
       roundTrip(v)
-    } else {
+    else
       intercept[MessageTypeCastException] {
         v.asRawValue()
       }
-    }
 
-    if (asBinary) {
+    if asBinary then
       v.getValueType shouldBe ValueType.BINARY
       roundTrip(v)
-    } else {
+    else
       intercept[MessageTypeCastException] {
         v.asBinaryValue()
       }
-    }
 
-    if (asString) {
+    if asString then
       v.getValueType shouldBe ValueType.STRING
       roundTrip(v)
-    } else {
+    else
       intercept[MessageTypeCastException] {
         v.asStringValue()
       }
-    }
 
-    if (asArray) {
+    if asArray then
       v.getValueType shouldBe ValueType.ARRAY
       roundTrip(v)
-    } else {
+    else
       intercept[MessageTypeCastException] {
         v.asArrayValue()
       }
-    }
 
-    if (asMap) {
+    if asMap then
       v.getValueType shouldBe ValueType.MAP
       roundTrip(v)
-    } else {
+    else
       intercept[MessageTypeCastException] {
         v.asMapValue()
       }
-    }
 
-    if (asExtension) {
+    if asExtension then
       v.getValueType shouldBe ValueType.EXTENSION
       roundTrip(v)
-    } else {
+    else
       intercept[MessageTypeCastException] {
         v.asExtensionValue()
       }
-    }
 
-    if (asTimestamp) {
+    if asTimestamp then
       v.getValueType shouldBe ValueType.EXTENSION
       roundTrip(v)
-    } else {
+    else
       intercept[MessageTypeCastException] {
         v.asTimestampValue()
       }
-    }
 
     v
-  }
+
+  end validateValue
 
   test("Variable") {
     test("read nil") {
       check(
         _.packNil,
-        checker = { v =>
-          val iv = validateValue(v.asNilValue(), asNil = true)
-          iv.toJson shouldBe "null"
-        }
+        checker =
+          v =>
+            val iv = validateValue(v.asNilValue(), asNil = true)
+            iv.toJson shouldBe "null"
       )
     }
 
     test("read integers") {
-      forAll { i: Int =>
+      forAll { (i: Int) =>
         check(
           _.packInt(i),
-          checker = { v =>
-            val iv = validateValue(v.asIntegerValue(), asInteger = true)
-            iv.asInt() shouldBe i
-            iv.asLong() shouldBe i.toLong
-          }
+          checker =
+            v =>
+              val iv = validateValue(v.asIntegerValue(), asInteger = true)
+              iv.asInt() shouldBe i
+              iv.asLong() shouldBe i.toLong
         )
       }
     }
 
     test("read double") {
-      forAll { x: Double =>
+      forAll { (x: Double) =>
         check(
           _.packDouble(x),
-          checker = { v =>
-            val iv = validateValue(v.asFloatValue(), asFloat = true)
-          //iv.toDouble shouldBe v
-          //iv.toFloat shouldBe x.toFloat
-          }
+          checker =
+            v =>
+              val iv = validateValue(v.asFloatValue(), asFloat = true)
+              // iv.toDouble shouldBe v
+              // iv.toFloat shouldBe x.toFloat
         )
       }
     }
 
     test("read boolean") {
-      forAll { x: Boolean =>
+      forAll { (x: Boolean) =>
         check(
           _.packBoolean(x),
-          checker = { v =>
-            val iv = validateValue(v.asBooleanValue(), asBoolean = true)
-            iv.getBoolean shouldBe x
-          }
+          checker =
+            v =>
+              val iv = validateValue(v.asBooleanValue(), asBoolean = true)
+              iv.getBoolean shouldBe x
         )
       }
     }
 
     test("read binary") {
-      forAll { x: Array[Byte] =>
+      forAll { (x: Array[Byte]) =>
         check(
           { packer =>
-            packer.packBinaryHeader(x.length); packer.addPayload(x)
+            packer.packBinaryHeader(x.length);
+            packer.addPayload(x)
           },
-          checker = { v =>
-            val iv = validateValue(v.asBinaryValue(), asBinary = true)
-            util.Arrays.equals(iv.asByteArray(), x)
-          }
+          checker =
+            v =>
+              val iv = validateValue(v.asBinaryValue(), asBinary = true)
+              util.Arrays.equals(iv.asByteArray(), x)
         )
       }
     }
 
     test("read string") {
-      forAll { x: String =>
+      forAll { (x: String) =>
         check(
           _.packString(x),
-          checker = { v =>
-            val iv = validateValue(v.asStringValue(), asString = true)
-            iv.asString() shouldBe x
-          }
+          checker =
+            v =>
+              val iv = validateValue(v.asStringValue(), asString = true)
+              iv.asString() shouldBe x
         )
       }
     }
 
     test("read array") {
-      forAll { x: Seq[Int] =>
+      forAll { (x: Seq[Int]) =>
         check(
           { packer =>
             packer.packArrayHeader(x.size)
-            x.foreach { packer.packInt(_) }
+            x.foreach {
+              packer.packInt(_)
+            }
           },
-          checker = { v =>
-            val iv  = validateValue(v.asArrayValue(), asArray = true)
-            val lst = iv.list().asScala.map(_.asIntegerValue().toInt)
-            lst shouldBe x
-          }
+          checker =
+            v =>
+              val iv  = validateValue(v.asArrayValue(), asArray = true)
+              val lst = iv.list().asScala.map(_.asIntegerValue().toInt)
+              lst shouldBe x
         )
       }
     }
 
     test("read map") {
-      forAll { x: Seq[Int] =>
+      forAll { (x: Seq[Int]) =>
         // Generate map with unique keys
-        val map = x.zipWithIndex.map { case (x, i) => (s"key-${i}", x) }
+        val map = x
+          .zipWithIndex
+          .map { case (x, i) =>
+            (s"key-${i}", x)
+          }
         check(
           { packer =>
             packer.packMapHeader(map.size)
@@ -283,27 +278,32 @@ class VariableTest extends AirSpec with PropertyCheck {
               packer.packInt(x._2)
             }
           },
-          checker = { v =>
-            val iv  = validateValue(v.asMapValue(), asMap = true)
-            val lst = iv.map().asScala.map(p => (p._1.asStringValue().asString(), p._2.asIntegerValue().asInt())).toSeq
-            lst.sortBy(_._1) shouldBe map.sortBy(_._1)
-          }
+          checker =
+            v =>
+              val iv  = validateValue(v.asMapValue(), asMap = true)
+              val lst =
+                iv.map()
+                  .asScala
+                  .map(p => (p._1.asStringValue().asString(), p._2.asIntegerValue().asInt()))
+                  .toSeq
+              lst.sortBy(_._1) shouldBe map.sortBy(_._1)
         )
       }
     }
 
     test("read timestamps") {
-      forAll { millis: Long =>
+      forAll { (millis: Long) =>
         val i = Instant.ofEpochMilli(millis)
         check(
           _.packTimestamp(i),
-          checker = { v =>
-            val ts = validateValue(v.asTimestampValue(), asTimestamp = true)
-            ts.isTimestampValue shouldBe true
-            ts.toInstant shouldBe i
-          }
+          checker =
+            v =>
+              val ts = validateValue(v.asTimestampValue(), asTimestamp = true)
+              ts.isTimestampValue shouldBe true
+              ts.toInstant shouldBe i
         )
       }
     }
   }
-}
+
+end VariableTest
diff --git a/msgpack-jackson/README.md b/msgpack-jackson/README.md
index f1710ff24..0156453ea 100644
--- a/msgpack-jackson/README.md
+++ b/msgpack-jackson/README.md
@@ -61,7 +61,13 @@ Only thing you need to do is to instantiate `MessagePackFactory` and pass it to
 Or more easily:
 
 ```java
-ObjectMapper objectMapper = new MessagePackMapper();
+  ObjectMapper objectMapper = new MessagePackMapper();
+```
+
+We strongly recommend to call `MessagePackMapper#handleBigIntegerAndBigDecimalAsString()` if you serialize and/or deserialize BigInteger/BigDecimal values. See [Serialize and deserialize BigDecimal as str type internally in MessagePack format](#serialize-and-deserialize-bigdecimal-as-str-type-internally-in-messagepack-format) for details.
+
+```java
+  ObjectMapper objectMapper = new MessagePackMapper().handleBigIntegerAndBigDecimalAsString();
 ```
 
 ### Serialization/Deserialization of List
@@ -224,9 +230,51 @@ When you want to use non-String value as a key of Map, use `MessagePackKeySerial
   System.out.println(deserialized);   // => {42=Hello}
 ```
 
+### Serialize and deserialize BigDecimal as str type internally in MessagePack format
+
+`jackson-dataformat-msgpack` represents BigDecimal values as float type in MessagePack format by default for backward compatibility. But the default behavior could fail when handling too large value for `double` type. So we strongly recommend to call `MessagePackMapper#handleBigIntegerAndBigDecimalAsString()` to internally handle BigDecimal values as String.
+
+```java
+  ObjectMapper objectMapper = new MessagePackMapper().handleBigIntegerAndBigDecimalAsString();
+
+  Pojo obj = new Pojo();
+  // This value is too large to be serialized as double
+  obj.value = new BigDecimal("1234567890.98765432100");
+
+  byte[] converted = objectMapper.writeValueAsBytes(obj);
+
+  System.out.println(objectMapper.readValue(converted, Pojo.class));   // => Pojo{value=1234567890.98765432100}
+```
+`MessagePackMapper#handleBigIntegerAndDecimalAsString()` is equivalent to the following configuration.
+
+```java
+  ObjectMapper objectMapper = new ObjectMapper(new MessagePackFactory());
+  objectMapper.configOverride(BigInteger.class).setFormat(JsonFormat.Value.forShape(JsonFormat.Shape.STRING));
+  objectMapper.configOverride(BigDecimal.class).setFormat(JsonFormat.Value.forShape(JsonFormat.Shape.STRING));
+```
+
+
+### Serialize and deserialize Instant instances as MessagePack extension type
+
+`timestamp` extension type is defined in MessagePack as type:-1. Registering `TimestampExtensionModule.INSTANCE` module enables automatic serialization and deserialization of java.time.Instant to/from the MessagePack extension type.
+
+```java
+    ObjectMapper objectMapper = new MessagePackMapper()
+                                    .registerModule(TimestampExtensionModule.INSTANCE);
+    Pojo pojo = new Pojo();
+    // The type of `timestamp` variable is Instant
+    pojo.timestamp = Instant.now();
+    byte[] bytes = objectMapper.writeValueAsBytes(pojo);
+
+    // The Instant instance is serialized as MessagePack extension type (type: -1)
+
+    Pojo deserialized = objectMapper.readValue(bytes, Pojo.class);
+    System.out.println(deserialized);   // "2022-09-14T08:47:24.922Z"
+```
+
 ### Deserialize extension types with ExtensionTypeCustomDeserializers
 
-`ExtensionTypeCustomDeserializers` helps you to deserialize extension types easily.
+`ExtensionTypeCustomDeserializers` helps you to deserialize your own custom extension types easily.
 
 #### Deserialize extension type value directly
 
@@ -253,8 +301,8 @@ When you want to use non-String value as a key of Map, use `MessagePackKeySerial
           return "Java";
       }
       return "Not Java";
-  }
-  );
+  });
+
   ObjectMapper objectMapper = new ObjectMapper(
           new MessagePackFactory().setExtTypeCustomDesers(extTypeCustomDesers));
 
@@ -442,4 +490,3 @@ There are a few options to fix this issue, but they introduce performance degred
   ObjectMapper objectMapper = new ObjectMapper(
     new MessagePackFactory().setReuseResourceInGenerator(false));
 ```
-
diff --git a/msgpack-jackson/src/main/java/org/msgpack/jackson/dataformat/ExtensionTypeCustomDeserializers.java b/msgpack-jackson/src/main/java/org/msgpack/jackson/dataformat/ExtensionTypeCustomDeserializers.java
index ae2e63537..aa5879755 100644
--- a/msgpack-jackson/src/main/java/org/msgpack/jackson/dataformat/ExtensionTypeCustomDeserializers.java
+++ b/msgpack-jackson/src/main/java/org/msgpack/jackson/dataformat/ExtensionTypeCustomDeserializers.java
@@ -35,15 +35,7 @@ public ExtensionTypeCustomDeserializers(ExtensionTypeCustomDeserializers src)
 
     public void addCustomDeser(byte type, final Deser deser)
     {
-        deserTable.put(type, new Deser()
-        {
-            @Override
-            public Object deserialize(byte[] data)
-                    throws IOException
-            {
-                return deser.deserialize(data);
-            }
-        });
+        deserTable.put(type, deser);
     }
 
     public Deser getDeser(byte type)
diff --git a/msgpack-jackson/src/main/java/org/msgpack/jackson/dataformat/JavaInfo.java b/msgpack-jackson/src/main/java/org/msgpack/jackson/dataformat/JavaInfo.java
new file mode 100644
index 000000000..f5fda8c28
--- /dev/null
+++ b/msgpack-jackson/src/main/java/org/msgpack/jackson/dataformat/JavaInfo.java
@@ -0,0 +1,41 @@
+//
+// MessagePack for Java
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+package org.msgpack.jackson.dataformat;
+
+import java.lang.reflect.Field;
+import java.util.function.Supplier;
+
+public final class JavaInfo
+{
+    static final Supplier<Boolean> STRING_VALUE_FIELD_IS_CHARS;
+    static {
+        boolean stringValueFieldIsChars = false;
+        try {
+            Field stringValueField = String.class.getDeclaredField("value");
+            stringValueFieldIsChars = stringValueField.getType() == char[].class;
+        }
+        catch (NoSuchFieldException ignored) {
+        }
+        if (stringValueFieldIsChars) {
+            STRING_VALUE_FIELD_IS_CHARS = () -> true;
+        }
+        else {
+            STRING_VALUE_FIELD_IS_CHARS = () -> false;
+        }
+    }
+
+    private JavaInfo() {}
+}
diff --git a/msgpack-jackson/src/main/java/org/msgpack/jackson/dataformat/JsonArrayFormat.java b/msgpack-jackson/src/main/java/org/msgpack/jackson/dataformat/JsonArrayFormat.java
index 9711e1b88..39155030e 100644
--- a/msgpack-jackson/src/main/java/org/msgpack/jackson/dataformat/JsonArrayFormat.java
+++ b/msgpack-jackson/src/main/java/org/msgpack/jackson/dataformat/JsonArrayFormat.java
@@ -2,7 +2,6 @@
 
 import com.fasterxml.jackson.annotation.JsonFormat;
 import com.fasterxml.jackson.databind.introspect.Annotated;
-import com.fasterxml.jackson.databind.introspect.AnnotatedClass;
 import com.fasterxml.jackson.databind.introspect.JacksonAnnotationIntrospector;
 
 import static com.fasterxml.jackson.annotation.JsonFormat.Shape.ARRAY;
@@ -33,21 +32,4 @@ public JsonFormat.Value findFormat(Annotated ann)
 
     return ARRAY_FORMAT;
   }
-
-  /**
-   * Defines that unknown properties will be ignored, and won't fail the un-marshalling process.
-   * Happens in case of de-serialization of a payload that contains more properties than the actual
-   * value type
-   */
-  @Override
-  public Boolean findIgnoreUnknownProperties(AnnotatedClass ac)
-  {
-    // If the entity contains JsonIgnoreProperties annotation, give it higher priority.
-    final Boolean precedenceIgnoreUnknownProperties = super.findIgnoreUnknownProperties(ac);
-    if (precedenceIgnoreUnknownProperties != null) {
-      return precedenceIgnoreUnknownProperties;
-    }
-
-    return true;
-  }
 }
diff --git a/msgpack-jackson/src/main/java/org/msgpack/jackson/dataformat/MessagePackExtensionType.java b/msgpack-jackson/src/main/java/org/msgpack/jackson/dataformat/MessagePackExtensionType.java
index 00b4f7de8..e11c2cd02 100644
--- a/msgpack-jackson/src/main/java/org/msgpack/jackson/dataformat/MessagePackExtensionType.java
+++ b/msgpack-jackson/src/main/java/org/msgpack/jackson/dataformat/MessagePackExtensionType.java
@@ -1,7 +1,6 @@
 package org.msgpack.jackson.dataformat;
 
 import com.fasterxml.jackson.core.JsonGenerator;
-import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.JsonSerializer;
 import com.fasterxml.jackson.databind.SerializerProvider;
 import com.fasterxml.jackson.databind.annotation.JsonSerialize;
@@ -52,7 +51,7 @@ public boolean equals(Object o)
     @Override
     public int hashCode()
     {
-        int result = (int) type;
+        int result = type;
         result = 31 * result + Arrays.hashCode(data);
         return result;
     }
@@ -61,7 +60,7 @@ public static class Serializer extends JsonSerializer<MessagePackExtensionType>
     {
         @Override
         public void serialize(MessagePackExtensionType value, JsonGenerator gen, SerializerProvider serializers)
-                throws IOException, JsonProcessingException
+                throws IOException
         {
             if (gen instanceof MessagePackGenerator) {
                 MessagePackGenerator msgpackGenerator = (MessagePackGenerator) gen;
diff --git a/msgpack-jackson/src/main/java/org/msgpack/jackson/dataformat/MessagePackFactory.java b/msgpack-jackson/src/main/java/org/msgpack/jackson/dataformat/MessagePackFactory.java
index 1e7acc5e2..865c0cf4d 100644
--- a/msgpack-jackson/src/main/java/org/msgpack/jackson/dataformat/MessagePackFactory.java
+++ b/msgpack-jackson/src/main/java/org/msgpack/jackson/dataformat/MessagePackFactory.java
@@ -18,8 +18,8 @@
 import com.fasterxml.jackson.core.JsonEncoding;
 import com.fasterxml.jackson.core.JsonFactory;
 import com.fasterxml.jackson.core.JsonGenerator;
-import com.fasterxml.jackson.core.JsonParseException;
 import com.fasterxml.jackson.core.JsonParser;
+import com.fasterxml.jackson.core.io.ContentReference;
 import com.fasterxml.jackson.core.io.IOContext;
 import org.msgpack.core.MessagePack;
 import org.msgpack.core.annotations.VisibleForTesting;
@@ -40,6 +40,7 @@ public class MessagePackFactory
     private final MessagePack.PackerConfig packerConfig;
     private boolean reuseResourceInGenerator = true;
     private boolean reuseResourceInParser = true;
+    private boolean supportIntegerKeys = false;
     private ExtensionTypeCustomDeserializers extTypeCustomDesers;
 
     public MessagePackFactory()
@@ -75,6 +76,12 @@ public MessagePackFactory setReuseResourceInParser(boolean reuseResourceInParser
         return this;
     }
 
+    public MessagePackFactory setSupportIntegerKeys(boolean supportIntegerKeys)
+    {
+        this.supportIntegerKeys = supportIntegerKeys;
+        return this;
+    }
+
     public MessagePackFactory setExtTypeCustomDesers(ExtensionTypeCustomDeserializers extTypeCustomDesers)
     {
         this.extTypeCustomDesers = extTypeCustomDesers;
@@ -85,7 +92,7 @@ public MessagePackFactory setExtTypeCustomDesers(ExtensionTypeCustomDeserializer
     public JsonGenerator createGenerator(OutputStream out, JsonEncoding enc)
             throws IOException
     {
-        return new MessagePackGenerator(_generatorFeatures, _objectCodec, out, packerConfig, reuseResourceInGenerator);
+        return new MessagePackGenerator(_generatorFeatures, _objectCodec, out, packerConfig, reuseResourceInGenerator, supportIntegerKeys);
     }
 
     @Override
@@ -97,24 +104,23 @@ public JsonGenerator createGenerator(File f, JsonEncoding enc)
 
     @Override
     public JsonGenerator createGenerator(Writer w)
-            throws IOException
     {
         throw new UnsupportedOperationException();
     }
 
     @Override
     public JsonParser createParser(byte[] data)
-            throws IOException, JsonParseException
+            throws IOException
     {
-        IOContext ioContext = _createContext(data, false);
+        IOContext ioContext = _createContext(ContentReference.rawReference(data), false);
         return _createParser(data, 0, data.length, ioContext);
     }
 
     @Override
     public JsonParser createParser(InputStream in)
-            throws IOException, JsonParseException
+            throws IOException
     {
-        IOContext ioContext = _createContext(in, false);
+        IOContext ioContext = _createContext(ContentReference.rawReference(in), false);
         return _createParser(in, ioContext);
     }
 
@@ -131,7 +137,7 @@ protected MessagePackParser _createParser(InputStream in, IOContext ctxt)
 
     @Override
     protected JsonParser _createParser(byte[] data, int offset, int len, IOContext ctxt)
-            throws IOException, JsonParseException
+            throws IOException
     {
         if (offset != 0 || len != data.length) {
             data = Arrays.copyOfRange(data, offset, offset + len);
@@ -155,12 +161,6 @@ MessagePack.PackerConfig getPackerConfig()
         return packerConfig;
     }
 
-    @VisibleForTesting
-    boolean isReuseResourceInGenerator()
-    {
-        return reuseResourceInGenerator;
-    }
-
     @VisibleForTesting
     boolean isReuseResourceInParser()
     {
@@ -178,4 +178,10 @@ public String getFormatName()
     {
         return "msgpack";
     }
+
+    @Override
+    public boolean canHandleBinaryNatively()
+    {
+        return true;
+    }
 }
diff --git a/msgpack-jackson/src/main/java/org/msgpack/jackson/dataformat/MessagePackGenerator.java b/msgpack-jackson/src/main/java/org/msgpack/jackson/dataformat/MessagePackGenerator.java
index 96aa6a063..3dde5604d 100644
--- a/msgpack-jackson/src/main/java/org/msgpack/jackson/dataformat/MessagePackGenerator.java
+++ b/msgpack-jackson/src/main/java/org/msgpack/jackson/dataformat/MessagePackGenerator.java
@@ -16,14 +16,18 @@
 package org.msgpack.jackson.dataformat;
 
 import com.fasterxml.jackson.core.Base64Variant;
-import com.fasterxml.jackson.core.JsonGenerationException;
 import com.fasterxml.jackson.core.ObjectCodec;
 import com.fasterxml.jackson.core.SerializableString;
 import com.fasterxml.jackson.core.base.GeneratorBase;
+import com.fasterxml.jackson.core.io.ContentReference;
+import com.fasterxml.jackson.core.io.IOContext;
 import com.fasterxml.jackson.core.io.SerializedString;
 import com.fasterxml.jackson.core.json.JsonWriteContext;
+import com.fasterxml.jackson.core.util.BufferRecycler;
 import org.msgpack.core.MessagePack;
 import org.msgpack.core.MessagePacker;
+import org.msgpack.core.annotations.Nullable;
+import org.msgpack.core.buffer.MessageBufferOutput;
 import org.msgpack.core.buffer.OutputStreamBufferOutput;
 
 import java.io.ByteArrayOutputStream;
@@ -33,84 +37,197 @@
 import java.math.BigInteger;
 import java.nio.ByteBuffer;
 import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
-import java.util.LinkedList;
 import java.util.List;
 
+import static org.msgpack.jackson.dataformat.JavaInfo.STRING_VALUE_FIELD_IS_CHARS;
+
 public class MessagePackGenerator
         extends GeneratorBase
 {
-    private static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");
+    private static final Charset DEFAULT_CHARSET = StandardCharsets.UTF_8;
+    private static final int IN_ROOT = 0;
+    private static final int IN_OBJECT = 1;
+    private static final int IN_ARRAY = 2;
     private final MessagePacker messagePacker;
-    private static ThreadLocal<OutputStreamBufferOutput> messageBufferOutputHolder = new ThreadLocal<OutputStreamBufferOutput>();
+    private static final ThreadLocal<OutputStreamBufferOutput> messageBufferOutputHolder = new ThreadLocal<>();
     private final OutputStream output;
     private final MessagePack.PackerConfig packerConfig;
-    private LinkedList<StackItem> stack;
-    private StackItem rootStackItem;
+    private final boolean supportIntegerKeys;
+
+    private int currentParentElementIndex = -1;
+    private int currentState = IN_ROOT;
+    private final List<Node> nodes;
+    private boolean isElementsClosed = false;
+
+    private static final class AsciiCharString
+    {
+        public final byte[] bytes;
+
+        public AsciiCharString(byte[] bytes)
+        {
+            this.bytes = bytes;
+        }
+    }
 
-    private abstract static class StackItem
+    private abstract static class Node
     {
-        protected List<Object> objectKeys = new ArrayList<Object>();
-        protected List<Object> objectValues = new ArrayList<Object>();
+        // Root containers have -1.
+        final int parentIndex;
 
-        abstract void addKey(Object key);
+        public Node(int parentIndex)
+        {
+            this.parentIndex = parentIndex;
+        }
+
+        abstract void incrementChildCount();
+
+        abstract int currentStateAsParent();
+    }
+
+    private abstract static class NodeContainer extends Node
+    {
+        // Only for containers.
+        int childCount;
 
-        void addValue(Object value)
+        public NodeContainer(int parentIndex)
         {
-            objectValues.add(value);
+            super(parentIndex);
         }
 
-        abstract List<Object> getKeys();
+        @Override
+        void incrementChildCount()
+        {
+            childCount++;
+        }
+    }
+
+    private static final class NodeArray extends NodeContainer
+    {
+        public NodeArray(int parentIndex)
+        {
+            super(parentIndex);
+        }
+
+        @Override
+        int currentStateAsParent()
+        {
+            return IN_ARRAY;
+        }
+    }
+
+    private static final class NodeObject extends NodeContainer
+    {
+        public NodeObject(int parentIndex)
+        {
+            super(parentIndex);
+        }
 
-        List<Object> getValues()
+        @Override
+        int currentStateAsParent()
         {
-            return objectValues;
+            return IN_OBJECT;
         }
     }
 
-    private static class StackItemForObject
-            extends StackItem
+    private static final class NodeEntryInArray extends Node
     {
+        final Object value;
+
+        public NodeEntryInArray(int parentIndex, Object value)
+        {
+            super(parentIndex);
+            this.value = value;
+        }
+
         @Override
-        void addKey(Object key)
+        void incrementChildCount()
         {
-            objectKeys.add(key);
+            throw new UnsupportedOperationException();
         }
 
         @Override
-        List<Object> getKeys()
+        int currentStateAsParent()
         {
-            return objectKeys;
+            throw new UnsupportedOperationException();
         }
     }
 
-    private static class StackItemForArray
-            extends StackItem
+    private static final class NodeEntryInObject extends Node
     {
+        final Object key;
+        // Lazily initialized.
+        Object value;
+
+        public NodeEntryInObject(int parentIndex, Object key)
+        {
+            super(parentIndex);
+            this.key = key;
+        }
+
         @Override
-        void addKey(Object key)
+        void incrementChildCount()
         {
-            throw new IllegalStateException("This method shouldn't be called");
+            assert value instanceof NodeContainer;
+            ((NodeContainer) value).childCount++;
         }
 
         @Override
-        List<Object> getKeys()
+        int currentStateAsParent()
         {
-            throw new IllegalStateException("This method shouldn't be called");
+            if (value instanceof NodeObject) {
+                return IN_OBJECT;
+            }
+            else if (value instanceof NodeArray) {
+                return IN_ARRAY;
+            }
+            else {
+                throw new AssertionError();
+            }
         }
     }
 
+    // This is an internal constructor for nested serialization.
+    @SuppressWarnings("deprecation")
+    private MessagePackGenerator(
+            int features,
+            ObjectCodec codec,
+            OutputStream out,
+            MessagePack.PackerConfig packerConfig,
+            boolean supportIntegerKeys)
+    {
+        super(features, codec, new IOContext(new BufferRecycler(), ContentReference.rawReference(out), false), JsonWriteContext.createRootContext(null));
+        this.output = out;
+        this.messagePacker = packerConfig.newPacker(out);
+        this.packerConfig = packerConfig;
+        this.nodes = new ArrayList<>();
+        this.supportIntegerKeys = supportIntegerKeys;
+    }
+
+    @SuppressWarnings("deprecation")
     public MessagePackGenerator(
             int features,
             ObjectCodec codec,
             OutputStream out,
             MessagePack.PackerConfig packerConfig,
-            boolean reuseResourceInGenerator)
+            boolean reuseResourceInGenerator,
+            boolean supportIntegerKeys)
             throws IOException
     {
-        super(features, codec);
+        super(features, codec, new IOContext(new BufferRecycler(), ContentReference.rawReference(out), false), JsonWriteContext.createRootContext(null));
         this.output = out;
+        this.messagePacker = packerConfig.newPacker(getMessageBufferOutputForOutputStream(out, reuseResourceInGenerator));
+        this.packerConfig = packerConfig;
+        this.nodes = new ArrayList<>();
+        this.supportIntegerKeys = supportIntegerKeys;
+    }
 
+    private MessageBufferOutput getMessageBufferOutputForOutputStream(
+            OutputStream out,
+            boolean reuseResourceInGenerator)
+            throws IOException
+    {
         OutputStreamBufferOutput messageBufferOutput;
         if (reuseResourceInGenerator) {
             messageBufferOutput = messageBufferOutputHolder.get();
@@ -125,91 +242,106 @@ public MessagePackGenerator(
         else {
             messageBufferOutput = new OutputStreamBufferOutput(out);
         }
-        this.messagePacker = packerConfig.newPacker(messageBufferOutput);
-
-        this.packerConfig = packerConfig;
+        return messageBufferOutput;
+    }
 
-        this.stack = new LinkedList<StackItem>();
+    private String currentStateStr()
+    {
+        switch (currentState) {
+            case IN_OBJECT:
+                return "IN_OBJECT";
+            case IN_ARRAY:
+                return "IN_ARRAY";
+            default:
+                return "IN_ROOT";
+        }
     }
 
     @Override
     public void writeStartArray()
-            throws IOException, JsonGenerationException
     {
-        _writeContext = _writeContext.createChildArrayContext();
-        stack.push(new StackItemForArray());
+        if (currentState == IN_OBJECT) {
+            Node node = nodes.get(nodes.size() - 1);
+            assert node instanceof NodeEntryInObject;
+            NodeEntryInObject nodeEntryInObject = (NodeEntryInObject) node;
+            nodeEntryInObject.value = new NodeArray(currentParentElementIndex);
+        }
+        else {
+            nodes.add(new NodeArray(currentParentElementIndex));
+        }
+        currentParentElementIndex = nodes.size() - 1;
+        currentState = IN_ARRAY;
     }
 
     @Override
     public void writeEndArray()
-            throws IOException, JsonGenerationException
+            throws IOException
     {
-        if (!_writeContext.inArray()) {
-            _reportError("Current context not an array but " + _writeContext.getTypeDesc());
+        if (currentState != IN_ARRAY) {
+            _reportError("Current context not an array but " + currentStateStr());
         }
-
-        getStackTopForArray();
-
-        _writeContext = _writeContext.getParent();
-
-        popStackAndStoreTheItemAsValue();
+        endCurrentContainer();
     }
 
     @Override
     public void writeStartObject()
-            throws IOException, JsonGenerationException
     {
-        _writeContext = _writeContext.createChildObjectContext();
-        stack.push(new StackItemForObject());
+        if (currentState == IN_OBJECT) {
+            Node node = nodes.get(nodes.size() - 1);
+            assert node instanceof NodeEntryInObject;
+            NodeEntryInObject nodeEntryInObject = (NodeEntryInObject) node;
+            nodeEntryInObject.value = new NodeObject(currentParentElementIndex);
+        }
+        else {
+            nodes.add(new NodeObject(currentParentElementIndex));
+        }
+        currentParentElementIndex = nodes.size() - 1;
+        currentState = IN_OBJECT;
     }
 
     @Override
     public void writeEndObject()
-            throws IOException, JsonGenerationException
+            throws IOException
     {
-        if (!_writeContext.inObject()) {
-            _reportError("Current context not an object but " + _writeContext.getTypeDesc());
+        if (currentState != IN_OBJECT) {
+            _reportError("Current context not an object but " + currentStateStr());
         }
+        endCurrentContainer();
+    }
 
-        StackItemForObject stackTop = getStackTopForObject();
-
-        if (stackTop.getKeys().size() != stackTop.getValues().size()) {
-            throw new IllegalStateException(
-                    String.format(
-                            "objectKeys.size() and objectValues.size() is not same: depth=%d, key=%d, value=%d",
-                            stack.size(), stackTop.getKeys().size(), stackTop.getValues().size()));
+    private void endCurrentContainer()
+    {
+        Node parent = nodes.get(currentParentElementIndex);
+        if (currentParentElementIndex == 0) {
+            isElementsClosed = true;
+            currentParentElementIndex = parent.parentIndex;
+            return;
         }
-        _writeContext = _writeContext.getParent();
 
-        popStackAndStoreTheItemAsValue();
+        currentParentElementIndex = parent.parentIndex;
+        assert currentParentElementIndex >= 0;
+        Node currentParent = nodes.get(currentParentElementIndex);
+        currentParent.incrementChildCount();
+        currentState = currentParent.currentStateAsParent();
     }
 
-    private void pack(Object v)
+    private void packNonContainer(Object v)
             throws IOException
     {
         MessagePacker messagePacker = getMessagePacker();
-        if (v == null) {
-            messagePacker.packNil();
+        if (v instanceof String) {
+            messagePacker.packString((String) v);
+        }
+        else if (v instanceof AsciiCharString) {
+            byte[] bytes = ((AsciiCharString) v).bytes;
+            messagePacker.packRawStringHeader(bytes.length);
+            messagePacker.writePayload(bytes);
         }
         else if (v instanceof Integer) {
             messagePacker.packInt((Integer) v);
         }
-        else if (v instanceof ByteBuffer) {
-            ByteBuffer bb = (ByteBuffer) v;
-            int len = bb.remaining();
-            if (bb.hasArray()) {
-                messagePacker.packBinaryHeader(len);
-                messagePacker.writePayload(bb.array(), bb.arrayOffset(), len);
-            }
-            else {
-                byte[] data = new byte[len];
-                bb.get(data);
-                messagePacker.packBinaryHeader(len);
-                messagePacker.addPayload(data);
-            }
-        }
-        else if (v instanceof String) {
-            messagePacker.packString((String) v);
+        else if (v == null) {
+            messagePacker.packNil();
         }
         else if (v instanceof Float) {
             messagePacker.packFloat((Float) v);
@@ -217,12 +349,6 @@ else if (v instanceof Float) {
         else if (v instanceof Long) {
             messagePacker.packLong((Long) v);
         }
-        else if (v instanceof StackItemForObject) {
-            packObject((StackItemForObject) v);
-        }
-        else if (v instanceof StackItemForArray) {
-            packArray((StackItemForArray) v);
-        }
         else if (v instanceof Double) {
             messagePacker.packDouble((Double) v);
         }
@@ -235,6 +361,20 @@ else if (v instanceof BigDecimal) {
         else if (v instanceof Boolean) {
             messagePacker.packBoolean((Boolean) v);
         }
+        else if (v instanceof ByteBuffer) {
+            ByteBuffer bb = (ByteBuffer) v;
+            int len = bb.remaining();
+            if (bb.hasArray()) {
+                messagePacker.packBinaryHeader(len);
+                messagePacker.writePayload(bb.array(), bb.arrayOffset(), len);
+            }
+            else {
+                byte[] data = new byte[len];
+                bb.get(data);
+                messagePacker.packBinaryHeader(len);
+                messagePacker.addPayload(data);
+            }
+        }
         else if (v instanceof MessagePackExtensionType) {
             MessagePackExtensionType extensionType = (MessagePackExtensionType) v;
             byte[] extData = extensionType.getData();
@@ -244,7 +384,7 @@ else if (v instanceof MessagePackExtensionType) {
         else {
             messagePacker.flush();
             ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
-            MessagePackGenerator messagePackGenerator = new MessagePackGenerator(getFeatureMask(), getCodec(), outputStream, packerConfig, false);
+            MessagePackGenerator messagePackGenerator = new MessagePackGenerator(getFeatureMask(), getCodec(), outputStream, packerConfig, supportIntegerKeys);
             getCodec().writeValue(messagePackGenerator, v);
             output.write(outputStream.toByteArray());
         }
@@ -260,10 +400,7 @@ private void packBigDecimal(BigDecimal decimal)
             BigInteger integer = decimal.toBigIntegerExact();
             messagePacker.packBigInteger(integer);
         }
-        catch (ArithmeticException e) {
-            failedToPackAsBI = true;
-        }
-        catch (IllegalArgumentException e) {
+        catch (ArithmeticException | IllegalArgumentException e) {
             failedToPackAsBI = true;
         }
 
@@ -278,200 +415,308 @@ private void packBigDecimal(BigDecimal decimal)
         }
     }
 
-    private void packObject(StackItemForObject stackItem)
+    private void packObject(NodeObject container)
             throws IOException
     {
-        List<Object> keys = stackItem.getKeys();
-        List<Object> values = stackItem.getValues();
+        MessagePacker messagePacker = getMessagePacker();
+        messagePacker.packMapHeader(container.childCount);
+    }
 
+    private void packArray(NodeArray container)
+            throws IOException
+    {
         MessagePacker messagePacker = getMessagePacker();
-        messagePacker.packMapHeader(keys.size());
+        messagePacker.packArrayHeader(container.childCount);
+    }
 
-        for (int i = 0; i < keys.size(); i++) {
-            pack(keys.get(i));
-            pack(values.get(i));
+    private void addKeyNode(Object key)
+    {
+        if (currentState != IN_OBJECT) {
+            throw new IllegalStateException();
         }
+        Node node = new NodeEntryInObject(currentParentElementIndex, key);
+        nodes.add(node);
     }
 
-    private void packArray(StackItemForArray stackItem)
-            throws IOException
+    private void addValueNode(Object value) throws IOException
     {
-        List<Object> values = stackItem.getValues();
+        switch (currentState) {
+            case IN_OBJECT: {
+                Node node = nodes.get(nodes.size() - 1);
+                assert node instanceof NodeEntryInObject;
+                NodeEntryInObject nodeEntryInObject = (NodeEntryInObject) node;
+                nodeEntryInObject.value = value;
+                nodes.get(node.parentIndex).incrementChildCount();
+                break;
+            }
+            case IN_ARRAY: {
+                Node node = new NodeEntryInArray(currentParentElementIndex, value);
+                nodes.add(node);
+                nodes.get(node.parentIndex).incrementChildCount();
+                break;
+            }
+            default:
+                packNonContainer(value);
+                flushMessagePacker();
+                break;
+        }
+    }
 
-        MessagePacker messagePacker = getMessagePacker();
-        messagePacker.packArrayHeader(values.size());
+    @Nullable
+    private byte[] getBytesIfAscii(char[] chars, int offset, int len)
+    {
+        byte[] bytes = new byte[len];
+        for (int i = offset; i < offset + len; i++) {
+            char c = chars[i];
+            if (c >= 0x80) {
+                return null;
+            }
+            bytes[i] = (byte) c;
+        }
+        return bytes;
+    }
+
+    private boolean areAllAsciiBytes(byte[] bytes, int offset, int len)
+    {
+        for (int i = offset; i < offset + len; i++) {
+            if ((bytes[i] & 0x80) != 0) {
+                return false;
+            }
+        }
+        return true;
+    }
 
-        for (int i = 0; i < values.size(); i++) {
-            Object v = values.get(i);
-            pack(v);
+    private void writeCharArrayTextKey(char[] text, int offset, int len)
+    {
+        byte[] bytes = getBytesIfAscii(text, offset, len);
+        if (bytes != null) {
+            addKeyNode(new AsciiCharString(bytes));
+            return;
+        }
+        addKeyNode(new String(text, offset, len));
+    }
+
+    private void writeCharArrayTextValue(char[] text, int offset, int len) throws IOException
+    {
+        byte[] bytes = getBytesIfAscii(text, offset, len);
+        if (bytes != null) {
+            addValueNode(new AsciiCharString(bytes));
+            return;
+        }
+        addValueNode(new String(text, offset, len));
+    }
+
+    private void writeByteArrayTextValue(byte[] text, int offset, int len) throws IOException
+    {
+        if (areAllAsciiBytes(text, offset, len)) {
+            addValueNode(new AsciiCharString(text));
+            return;
+        }
+        addValueNode(new String(text, offset, len, DEFAULT_CHARSET));
+    }
+
+    private void writeByteArrayTextKey(byte[] text, int offset, int len) throws IOException
+    {
+        if (areAllAsciiBytes(text, offset, len)) {
+            addValueNode(new AsciiCharString(text));
+            return;
+        }
+        addValueNode(new String(text, offset, len, DEFAULT_CHARSET));
+    }
+
+    @Override
+    public void writeFieldId(long id) throws IOException
+    {
+        if (this.supportIntegerKeys) {
+            addKeyNode(id);
+        }
+        else {
+            super.writeFieldId(id);
         }
     }
 
     @Override
     public void writeFieldName(String name)
-            throws IOException, JsonGenerationException
     {
-        addKeyToStackTop(name);
+        if (STRING_VALUE_FIELD_IS_CHARS.get()) {
+            char[] chars = name.toCharArray();
+            writeCharArrayTextKey(chars, 0, chars.length);
+        }
+        else {
+            addKeyNode(name);
+        }
     }
 
     @Override
     public void writeFieldName(SerializableString name)
-            throws IOException
     {
-        if (name instanceof MessagePackSerializedString) {
-            addKeyToStackTop(((MessagePackSerializedString) name).getRawValue());
+        if (name instanceof SerializedString) {
+            writeFieldName(name.getValue());
         }
-        else if (name instanceof SerializedString) {
-            addKeyToStackTop(name.getValue());
+        else if (name instanceof MessagePackSerializedString) {
+            addKeyNode(((MessagePackSerializedString) name).getRawValue());
         }
         else {
-            System.out.println(name.getClass());
             throw new IllegalArgumentException("Unsupported key: " + name);
         }
     }
 
     @Override
     public void writeString(String text)
-            throws IOException, JsonGenerationException
+            throws IOException
     {
-        addValueToStackTop(text);
+        if (STRING_VALUE_FIELD_IS_CHARS.get()) {
+            char[] chars = text.toCharArray();
+            writeCharArrayTextValue(chars, 0, chars.length);
+        }
+        else {
+            addValueNode(text);
+        }
     }
 
     @Override
     public void writeString(char[] text, int offset, int len)
-            throws IOException, JsonGenerationException
+            throws IOException
     {
-        addValueToStackTop(new String(text, offset, len));
+        writeCharArrayTextValue(text, offset, len);
     }
 
     @Override
     public void writeRawUTF8String(byte[] text, int offset, int length)
-            throws IOException, JsonGenerationException
+            throws IOException
     {
-        addValueToStackTop(new String(text, offset, length, DEFAULT_CHARSET));
+        writeByteArrayTextValue(text, offset, length);
     }
 
     @Override
     public void writeUTF8String(byte[] text, int offset, int length)
-            throws IOException, JsonGenerationException
+            throws IOException
     {
-        addValueToStackTop(new String(text, offset, length, DEFAULT_CHARSET));
+        writeByteArrayTextValue(text, offset, length);
     }
 
     @Override
     public void writeRaw(String text)
-            throws IOException, JsonGenerationException
+            throws IOException
     {
-        addValueToStackTop(text);
+        if (STRING_VALUE_FIELD_IS_CHARS.get()) {
+            char[] chars = text.toCharArray();
+            writeCharArrayTextValue(chars, 0, chars.length);
+        }
+        else {
+            addValueNode(text);
+        }
     }
 
     @Override
     public void writeRaw(String text, int offset, int len)
-            throws IOException, JsonGenerationException
+            throws IOException
     {
-        addValueToStackTop(text.substring(0, len));
+        // TODO: There is room to optimize this.
+        char[] chars = text.toCharArray();
+        writeCharArrayTextValue(chars, offset, len);
     }
 
     @Override
     public void writeRaw(char[] text, int offset, int len)
-            throws IOException, JsonGenerationException
+            throws IOException
     {
-        addValueToStackTop(new String(text, offset, len));
+        writeCharArrayTextValue(text, offset, len);
     }
 
     @Override
     public void writeRaw(char c)
-            throws IOException, JsonGenerationException
+            throws IOException
     {
-        addValueToStackTop(String.valueOf(c));
+        writeCharArrayTextValue(new char[] { c }, 0, 1);
     }
 
     @Override
     public void writeBinary(Base64Variant b64variant, byte[] data, int offset, int len)
-            throws IOException, JsonGenerationException
+            throws IOException
     {
-        addValueToStackTop(ByteBuffer.wrap(data, offset, len));
+        addValueNode(ByteBuffer.wrap(data, offset, len));
     }
 
     @Override
     public void writeNumber(int v)
-            throws IOException, JsonGenerationException
+            throws IOException
     {
-        addValueToStackTop(Integer.valueOf(v));
+        addValueNode(v);
     }
 
     @Override
     public void writeNumber(long v)
-            throws IOException, JsonGenerationException
+            throws IOException
     {
-        addValueToStackTop(Long.valueOf(v));
+        addValueNode(v);
     }
 
     @Override
     public void writeNumber(BigInteger v)
-            throws IOException, JsonGenerationException
+            throws IOException
     {
-        addValueToStackTop(v);
+        addValueNode(v);
     }
 
     @Override
     public void writeNumber(double d)
-            throws IOException, JsonGenerationException
+            throws IOException
     {
-        addValueToStackTop(Double.valueOf(d));
+        addValueNode(d);
     }
 
     @Override
     public void writeNumber(float f)
-            throws IOException, JsonGenerationException
+            throws IOException
     {
-        addValueToStackTop(Float.valueOf(f));
+        addValueNode(f);
     }
 
     @Override
     public void writeNumber(BigDecimal dec)
-            throws IOException, JsonGenerationException
+            throws IOException
     {
-        addValueToStackTop(dec);
+        addValueNode(dec);
     }
 
     @Override
     public void writeNumber(String encodedValue)
-            throws IOException, JsonGenerationException, UnsupportedOperationException
+            throws IOException, UnsupportedOperationException
     {
         // There is a room to improve this API's performance while the implementation is robust.
         // If users can use other MessagePackGenerator#writeNumber APIs that accept
         // proper numeric types not String, it's better to use the other APIs instead.
         try {
             long l = Long.parseLong(encodedValue);
-            addValueToStackTop(l);
+            addValueNode(l);
             return;
         }
-        catch (NumberFormatException e) {
+        catch (NumberFormatException ignored) {
         }
 
         try {
             double d = Double.parseDouble(encodedValue);
-            addValueToStackTop(d);
+            addValueNode(d);
             return;
         }
-        catch (NumberFormatException e) {
+        catch (NumberFormatException ignored) {
         }
 
         try {
             BigInteger bi = new BigInteger(encodedValue);
-            addValueToStackTop(bi);
+            addValueNode(bi);
             return;
         }
-        catch (NumberFormatException e) {
+        catch (NumberFormatException ignored) {
         }
 
         try {
             BigDecimal bc = new BigDecimal(encodedValue);
-            addValueToStackTop(bc);
+            addValueNode(bc);
             return;
         }
-        catch (NumberFormatException e) {
+        catch (NumberFormatException ignored) {
         }
 
         throw new NumberFormatException(encodedValue);
@@ -479,22 +724,22 @@ public void writeNumber(String encodedValue)
 
     @Override
     public void writeBoolean(boolean state)
-            throws IOException, JsonGenerationException
+            throws IOException
     {
-        addValueToStackTop(Boolean.valueOf(state));
+        addValueNode(state);
     }
 
     @Override
     public void writeNull()
-            throws IOException, JsonGenerationException
+            throws IOException
     {
-        addValueToStackTop(null);
+        addValueNode(null);
     }
 
     public void writeExtensionType(MessagePackExtensionType extensionType)
             throws IOException
     {
-        addValueToStackTop(extensionType);
+        addValueNode(extensionType);
     }
 
     @Override
@@ -516,19 +761,42 @@ public void close()
     public void flush()
             throws IOException
     {
-        if (rootStackItem != null) {
-            if (rootStackItem instanceof StackItemForObject) {
-                packObject((StackItemForObject) rootStackItem);
+        if (!isElementsClosed) {
+            // The whole elements are not closed yet.
+            return;
+        }
+
+        for (int i = 0; i < nodes.size(); i++) {
+            Node node = nodes.get(i);
+            if (node instanceof NodeEntryInObject) {
+                NodeEntryInObject nodeEntry = (NodeEntryInObject) node;
+                packNonContainer(nodeEntry.key);
+                if (nodeEntry.value instanceof NodeObject) {
+                    packObject((NodeObject) nodeEntry.value);
+                }
+                else if (nodeEntry.value instanceof NodeArray) {
+                    packArray((NodeArray) nodeEntry.value);
+                }
+                else {
+                    packNonContainer(nodeEntry.value);
+                }
+            }
+            else if (node instanceof NodeObject) {
+                packObject((NodeObject) node);
             }
-            else if (rootStackItem instanceof StackItemForArray) {
-                packArray((StackItemForArray) rootStackItem);
+            else if (node instanceof NodeEntryInArray) {
+                packNonContainer(((NodeEntryInArray) node).value);
+            }
+            else if (node instanceof NodeArray) {
+                packArray((NodeArray) node);
             }
             else {
-                throw new IllegalStateException("Unexpected rootStackItem: " + rootStackItem);
+                throw new AssertionError();
             }
-            rootStackItem = null;
-            flushMessagePacker();
         }
+        flushMessagePacker();
+        nodes.clear();
+        isElementsClosed = false;
     }
 
     private void flushMessagePacker()
@@ -541,76 +809,18 @@ private void flushMessagePacker()
     @Override
     protected void _releaseBuffers()
     {
-    }
-
-    @Override
-    protected void _verifyValueWrite(String typeMsg)
-            throws IOException, JsonGenerationException
-    {
-        int status = _writeContext.writeValue();
-        if (status == JsonWriteContext.STATUS_EXPECT_NAME) {
-            _reportError("Can not " + typeMsg + ", expecting field name");
-        }
-    }
-
-    private StackItem getStackTop()
-    {
-        if (stack.isEmpty()) {
-            throw new IllegalStateException("The stack is empty");
-        }
-        return stack.getFirst();
-    }
-
-    private StackItemForObject getStackTopForObject()
-    {
-        StackItem stackTop = getStackTop();
-        if (!(stackTop instanceof StackItemForObject)) {
-            throw new IllegalStateException("The stack top should be Object: " + stackTop);
-        }
-        return (StackItemForObject) stackTop;
-    }
-
-    private StackItemForArray getStackTopForArray()
-    {
-        StackItem stackTop = getStackTop();
-        if (!(stackTop instanceof StackItemForArray)) {
-            throw new IllegalStateException("The stack top should be Array: " + stackTop);
-        }
-        return (StackItemForArray) stackTop;
-    }
-
-    private void addKeyToStackTop(Object key)
-    {
-        getStackTop().addKey(key);
-    }
-
-    private void addValueToStackTop(Object value)
-            throws IOException
-    {
-        if (stack.isEmpty()) {
-            pack(value);
-            flushMessagePacker();
+        try {
+            messagePacker.close();
         }
-        else {
-            getStackTop().addValue(value);
+        catch (IOException e) {
+            throw new RuntimeException("Failed to close MessagePacker", e);
         }
     }
 
-    private void popStackAndStoreTheItemAsValue()
-            throws IOException
+    @Override
+    protected void _verifyValueWrite(String typeMsg) throws IOException
     {
-        StackItem child = stack.pop();
-        if (stack.size() > 0) {
-            addValueToStackTop(child);
-        }
-        else {
-            if (rootStackItem != null) {
-                throw new IllegalStateException("rootStackItem is not null");
-            }
-            else {
-                rootStackItem = child;
-            }
-        }
+        // FIXME?
     }
 
     private MessagePacker getMessagePacker()
diff --git a/msgpack-jackson/src/main/java/org/msgpack/jackson/dataformat/MessagePackKeySerializer.java b/msgpack-jackson/src/main/java/org/msgpack/jackson/dataformat/MessagePackKeySerializer.java
index 8eaa80146..36fb235d5 100644
--- a/msgpack-jackson/src/main/java/org/msgpack/jackson/dataformat/MessagePackKeySerializer.java
+++ b/msgpack-jackson/src/main/java/org/msgpack/jackson/dataformat/MessagePackKeySerializer.java
@@ -15,7 +15,6 @@
 //
 package org.msgpack.jackson.dataformat;
 
-import com.fasterxml.jackson.core.JsonGenerationException;
 import com.fasterxml.jackson.core.JsonGenerator;
 import com.fasterxml.jackson.databind.SerializerProvider;
 import com.fasterxml.jackson.databind.ser.std.StdSerializer;
@@ -32,7 +31,7 @@ public MessagePackKeySerializer()
 
     @Override
     public void serialize(Object value, JsonGenerator jgen, SerializerProvider provider)
-            throws JsonGenerationException, IOException
+            throws IOException
     {
         jgen.writeFieldName(new MessagePackSerializedString(value));
     }
diff --git a/msgpack-jackson/src/main/java/org/msgpack/jackson/dataformat/MessagePackMapper.java b/msgpack-jackson/src/main/java/org/msgpack/jackson/dataformat/MessagePackMapper.java
index 3c3d228b0..144c8d1a5 100644
--- a/msgpack-jackson/src/main/java/org/msgpack/jackson/dataformat/MessagePackMapper.java
+++ b/msgpack-jackson/src/main/java/org/msgpack/jackson/dataformat/MessagePackMapper.java
@@ -15,9 +15,13 @@
 //
 package org.msgpack.jackson.dataformat;
 
+import com.fasterxml.jackson.annotation.JsonFormat;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.cfg.MapperBuilder;
 
+import java.math.BigDecimal;
+import java.math.BigInteger;
+
 public class MessagePackMapper extends ObjectMapper
 {
     private static final long serialVersionUID = 3L;
@@ -40,6 +44,23 @@ public MessagePackMapper(MessagePackFactory f)
         super(f);
     }
 
+    public MessagePackMapper handleBigIntegerAsString()
+    {
+        configOverride(BigInteger.class).setFormat(JsonFormat.Value.forShape(JsonFormat.Shape.STRING));
+        return this;
+    }
+
+    public MessagePackMapper handleBigDecimalAsString()
+    {
+        configOverride(BigDecimal.class).setFormat(JsonFormat.Value.forShape(JsonFormat.Shape.STRING));
+        return this;
+    }
+
+    public MessagePackMapper handleBigIntegerAndBigDecimalAsString()
+    {
+        return handleBigIntegerAsString().handleBigDecimalAsString();
+    }
+
     public static Builder builder()
     {
         return new Builder(new MessagePackMapper());
diff --git a/msgpack-jackson/src/main/java/org/msgpack/jackson/dataformat/MessagePackParser.java b/msgpack-jackson/src/main/java/org/msgpack/jackson/dataformat/MessagePackParser.java
index 2a95b69a0..72aeed205 100644
--- a/msgpack-jackson/src/main/java/org/msgpack/jackson/dataformat/MessagePackParser.java
+++ b/msgpack-jackson/src/main/java/org/msgpack/jackson/dataformat/MessagePackParser.java
@@ -17,9 +17,7 @@
 
 import com.fasterxml.jackson.core.Base64Variant;
 import com.fasterxml.jackson.core.JsonLocation;
-import com.fasterxml.jackson.core.JsonParseException;
 import com.fasterxml.jackson.core.JsonParser;
-import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.core.JsonStreamContext;
 import com.fasterxml.jackson.core.JsonToken;
 import com.fasterxml.jackson.core.ObjectCodec;
@@ -28,7 +26,6 @@
 import com.fasterxml.jackson.core.io.IOContext;
 import com.fasterxml.jackson.core.io.JsonEOFException;
 import com.fasterxml.jackson.core.json.DupDetector;
-import com.fasterxml.jackson.core.json.JsonReadContext;
 import org.msgpack.core.ExtensionTypeHeader;
 import org.msgpack.core.MessageFormat;
 import org.msgpack.core.MessagePack;
@@ -42,27 +39,29 @@
 import java.io.InputStream;
 import java.math.BigDecimal;
 import java.math.BigInteger;
-import java.util.LinkedList;
+import java.nio.charset.StandardCharsets;
+
+import static org.msgpack.jackson.dataformat.JavaInfo.STRING_VALUE_FIELD_IS_CHARS;
 
 public class MessagePackParser
         extends ParserMinimalBase
 {
-    private static final ThreadLocal<Tuple<Object, MessageUnpacker>> messageUnpackerHolder =
-            new ThreadLocal<Tuple<Object, MessageUnpacker>>();
+    private static final ThreadLocal<Tuple<Object, MessageUnpacker>> messageUnpackerHolder = new ThreadLocal<>();
     private final MessageUnpacker messageUnpacker;
 
-    private static final BigInteger LONG_MIN = BigInteger.valueOf((long) Long.MIN_VALUE);
-    private static final BigInteger LONG_MAX = BigInteger.valueOf((long) Long.MAX_VALUE);
+    private static final BigInteger LONG_MIN = BigInteger.valueOf(Long.MIN_VALUE);
+    private static final BigInteger LONG_MAX = BigInteger.valueOf(Long.MAX_VALUE);
 
     private ObjectCodec codec;
-    private JsonReadContext parsingContext;
+    private MessagePackReadContext streamReadContext;
 
-    private final LinkedList<StackItem> stack = new LinkedList<StackItem>();
     private boolean isClosed;
     private long tokenPosition;
     private long currentPosition;
     private final IOContext ioContext;
     private ExtensionTypeCustomDeserializers extTypeCustomDesers;
+    private final byte[] tempBytes = new byte[64];
+    private final char[] tempChars = new char[64];
 
     private enum Type
     {
@@ -76,51 +75,6 @@ private enum Type
     private String stringValue;
     private BigInteger biValue;
     private MessagePackExtensionType extensionTypeValue;
-    private boolean reuseResourceInParser;
-
-    private abstract static class StackItem
-    {
-        private long numOfElements;
-
-        protected StackItem(long numOfElements)
-        {
-            this.numOfElements = numOfElements;
-        }
-
-        public void consume()
-        {
-            numOfElements--;
-        }
-
-        public boolean isEmpty()
-        {
-            return numOfElements == 0;
-        }
-    }
-
-    private static class StackItemForObject
-            extends StackItem
-    {
-        StackItemForObject(long numOfElements)
-        {
-            super(numOfElements);
-        }
-    }
-
-    private static class StackItemForArray
-            extends StackItem
-    {
-        StackItemForArray(long numOfElements)
-        {
-            super(numOfElements);
-        }
-    }
-
-    public MessagePackParser(IOContext ctxt, int features, ObjectCodec objectCodec, InputStream in)
-            throws IOException
-    {
-        this(ctxt, features, objectCodec, in, true);
-    }
 
     public MessagePackParser(
             IOContext ctxt,
@@ -133,12 +87,6 @@ public MessagePackParser(
         this(ctxt, features, new InputStreamBufferInput(in), objectCodec, in, reuseResourceInParser);
     }
 
-    public MessagePackParser(IOContext ctxt, int features, ObjectCodec objectCodec, byte[] bytes)
-            throws IOException
-    {
-        this(ctxt, features, objectCodec, bytes, true);
-    }
-
     public MessagePackParser(
             IOContext ctxt,
             int features,
@@ -158,23 +106,18 @@ private MessagePackParser(IOContext ctxt,
             boolean reuseResourceInParser)
             throws IOException
     {
-        super(features);
+        super(features, ctxt.streamReadConstraints());
 
         this.codec = objectCodec;
         ioContext = ctxt;
         DupDetector dups = Feature.STRICT_DUPLICATE_DETECTION.enabledIn(features)
                 ? DupDetector.rootDetector(this) : null;
-        parsingContext = JsonReadContext.createRootContext(dups);
-        this.reuseResourceInParser = reuseResourceInParser;
+        streamReadContext = MessagePackReadContext.createRootContext(dups);
         if (!reuseResourceInParser) {
-            this.messageUnpacker = MessagePack.newDefaultUnpacker(input);
+            messageUnpacker = MessagePack.newDefaultUnpacker(input);
             return;
         }
-        else {
-            this.messageUnpacker = null;
-        }
 
-        MessageUnpacker messageUnpacker;
         Tuple<Object, MessageUnpacker> messageUnpackerTuple = messageUnpackerHolder.get();
         if (messageUnpackerTuple == null) {
             messageUnpacker = MessagePack.newDefaultUnpacker(input);
@@ -189,7 +132,7 @@ private MessagePackParser(IOContext ctxt,
             }
             messageUnpacker = messageUnpackerTuple.second();
         }
-        messageUnpackerHolder.set(new Tuple<Object, MessageUnpacker>(src, messageUnpacker));
+        messageUnpackerHolder.set(new Tuple<>(src, messageUnpacker));
     }
 
     public void setExtensionTypeCustomDeserializers(ExtensionTypeCustomDeserializers extTypeCustomDesers)
@@ -215,21 +158,47 @@ public Version version()
         return null;
     }
 
+    private String unpackString(MessageUnpacker messageUnpacker) throws IOException
+    {
+        int strLen = messageUnpacker.unpackRawStringHeader();
+        if (strLen <= tempBytes.length) {
+            messageUnpacker.readPayload(tempBytes, 0, strLen);
+            if (STRING_VALUE_FIELD_IS_CHARS.get()) {
+                for (int i = 0; i < strLen; i++) {
+                    byte b = tempBytes[i];
+                    if ((0x80 & b) != 0) {
+                        return new String(tempBytes, 0, strLen, StandardCharsets.UTF_8);
+                    }
+                    tempChars[i] = (char) b;
+                }
+                return new String(tempChars, 0, strLen);
+            }
+            else {
+                return new String(tempBytes, 0, strLen);
+            }
+        }
+        else {
+            byte[] bytes = messageUnpacker.readPayload(strLen);
+            return new String(bytes, 0, strLen, StandardCharsets.UTF_8);
+        }
+    }
+
     @Override
-    public JsonToken nextToken()
-            throws IOException, JsonParseException
+    public JsonToken nextToken() throws IOException
     {
-        MessageUnpacker messageUnpacker = getMessageUnpacker();
         tokenPosition = messageUnpacker.getTotalReadBytes();
 
-        JsonToken nextToken = null;
-        if (parsingContext.inObject() || parsingContext.inArray()) {
-            if (stack.getFirst().isEmpty()) {
-                stack.pop();
-                _currToken = parsingContext.inObject() ? JsonToken.END_OBJECT : JsonToken.END_ARRAY;
-                parsingContext = parsingContext.getParent();
-
-                return _currToken;
+        boolean isObjectValueSet = streamReadContext.inObject() && _currToken != JsonToken.FIELD_NAME;
+        if (isObjectValueSet) {
+            if (!streamReadContext.expectMoreValues()) {
+                streamReadContext = streamReadContext.getParent();
+                return _updateToken(JsonToken.END_OBJECT);
+            }
+        }
+        else if (streamReadContext.inArray()) {
+            if (!streamReadContext.expectMoreValues()) {
+                streamReadContext = streamReadContext.getParent();
+                return _updateToken(JsonToken.END_ARRAY);
             }
         }
 
@@ -238,24 +207,19 @@ public JsonToken nextToken()
         }
 
         MessageFormat format = messageUnpacker.getNextFormat();
-        ValueType valueType = messageUnpacker.getNextFormat().getValueType();
-
-        // We should push a new StackItem lazily after updating the current stack.
-        StackItem newStack = null;
+        ValueType valueType = format.getValueType();
 
+        JsonToken nextToken;
         switch (valueType) {
-            case NIL:
-                messageUnpacker.unpackNil();
-                nextToken = JsonToken.VALUE_NULL;
-                break;
-            case BOOLEAN:
-                boolean b = messageUnpacker.unpackBoolean();
-                if (parsingContext.inObject() && _currToken != JsonToken.FIELD_NAME) {
-                    parsingContext.setCurrentName(Boolean.toString(b));
+            case STRING:
+                type = Type.STRING;
+                stringValue = unpackString(messageUnpacker);
+                if (isObjectValueSet) {
+                    streamReadContext.setCurrentName(stringValue);
                     nextToken = JsonToken.FIELD_NAME;
                 }
                 else {
-                    nextToken = b ? JsonToken.VALUE_TRUE : JsonToken.VALUE_FALSE;
+                    nextToken = JsonToken.VALUE_STRING;
                 }
                 break;
             case INTEGER:
@@ -289,42 +253,45 @@ public JsonToken nextToken()
                         break;
                 }
 
-                if (parsingContext.inObject() && _currToken != JsonToken.FIELD_NAME) {
-                    parsingContext.setCurrentName(String.valueOf(v));
+                if (isObjectValueSet) {
+                    streamReadContext.setCurrentName(String.valueOf(v));
                     nextToken = JsonToken.FIELD_NAME;
                 }
                 else {
                     nextToken = JsonToken.VALUE_NUMBER_INT;
                 }
                 break;
-            case FLOAT:
-                type = Type.DOUBLE;
-                doubleValue = messageUnpacker.unpackDouble();
-                if (parsingContext.inObject() && _currToken != JsonToken.FIELD_NAME) {
-                    parsingContext.setCurrentName(String.valueOf(doubleValue));
+            case NIL:
+                messageUnpacker.unpackNil();
+                nextToken = JsonToken.VALUE_NULL;
+                break;
+            case BOOLEAN:
+                boolean b = messageUnpacker.unpackBoolean();
+                if (isObjectValueSet) {
+                    streamReadContext.setCurrentName(Boolean.toString(b));
                     nextToken = JsonToken.FIELD_NAME;
                 }
                 else {
-                    nextToken = JsonToken.VALUE_NUMBER_FLOAT;
+                    nextToken = b ? JsonToken.VALUE_TRUE : JsonToken.VALUE_FALSE;
                 }
                 break;
-            case STRING:
-                type = Type.STRING;
-                stringValue = messageUnpacker.unpackString();
-                if (parsingContext.inObject() && _currToken != JsonToken.FIELD_NAME) {
-                    parsingContext.setCurrentName(stringValue);
+            case FLOAT:
+                type = Type.DOUBLE;
+                doubleValue = messageUnpacker.unpackDouble();
+                if (isObjectValueSet) {
+                    streamReadContext.setCurrentName(String.valueOf(doubleValue));
                     nextToken = JsonToken.FIELD_NAME;
                 }
                 else {
-                    nextToken = JsonToken.VALUE_STRING;
+                    nextToken = JsonToken.VALUE_NUMBER_FLOAT;
                 }
                 break;
             case BINARY:
                 type = Type.BYTES;
                 int len = messageUnpacker.unpackBinaryHeader();
                 bytesValue = messageUnpacker.readPayload(len);
-                if (parsingContext.inObject() && _currToken != JsonToken.FIELD_NAME) {
-                    parsingContext.setCurrentName(new String(bytesValue, MessagePack.UTF8));
+                if (isObjectValueSet) {
+                    streamReadContext.setCurrentName(new String(bytesValue, MessagePack.UTF8));
                     nextToken = JsonToken.FIELD_NAME;
                 }
                 else {
@@ -332,17 +299,19 @@ public JsonToken nextToken()
                 }
                 break;
             case ARRAY:
-                newStack = new StackItemForArray(messageUnpacker.unpackArrayHeader());
+                nextToken = JsonToken.START_ARRAY;
+                streamReadContext = streamReadContext.createChildArrayContext(messageUnpacker.unpackArrayHeader());
                 break;
             case MAP:
-                newStack = new StackItemForObject(messageUnpacker.unpackMapHeader());
+                nextToken = JsonToken.START_OBJECT;
+                streamReadContext = streamReadContext.createChildObjectContext(messageUnpacker.unpackMapHeader());
                 break;
             case EXTENSION:
                 type = Type.EXT;
                 ExtensionTypeHeader header = messageUnpacker.unpackExtensionTypeHeader();
                 extensionTypeValue = new MessagePackExtensionType(header.getType(), messageUnpacker.readPayload(header.getLength()));
-                if (parsingContext.inObject() && _currToken != JsonToken.FIELD_NAME) {
-                    parsingContext.setCurrentName(deserializedExtensionTypeValue().toString());
+                if (isObjectValueSet) {
+                    streamReadContext.setCurrentName(deserializedExtensionTypeValue().toString());
                     nextToken = JsonToken.FIELD_NAME;
                 }
                 else {
@@ -354,35 +323,18 @@ public JsonToken nextToken()
         }
         currentPosition = messageUnpacker.getTotalReadBytes();
 
-        if (parsingContext.inObject() && nextToken != JsonToken.FIELD_NAME || parsingContext.inArray()) {
-            stack.getFirst().consume();
-        }
-
-        if (newStack != null) {
-            stack.push(newStack);
-            if (newStack instanceof StackItemForArray) {
-                nextToken = JsonToken.START_ARRAY;
-                parsingContext = parsingContext.createChildArrayContext(-1, -1);
-            }
-            else if (newStack instanceof StackItemForObject) {
-                nextToken = JsonToken.START_OBJECT;
-                parsingContext = parsingContext.createChildObjectContext(-1, -1);
-            }
-        }
-        _currToken = nextToken;
+        _updateToken(nextToken);
 
         return nextToken;
     }
 
     @Override
     protected void _handleEOF()
-            throws JsonParseException
     {
     }
 
     @Override
-    public String getText()
-            throws IOException, JsonParseException
+    public String getText() throws IOException
     {
         switch (type) {
             case STRING:
@@ -405,8 +357,7 @@ public String getText()
     }
 
     @Override
-    public char[] getTextCharacters()
-            throws IOException, JsonParseException
+    public char[] getTextCharacters() throws IOException
     {
         return getText().toCharArray();
     }
@@ -418,22 +369,19 @@ public boolean hasTextCharacters()
     }
 
     @Override
-    public int getTextLength()
-            throws IOException, JsonParseException
+    public int getTextLength() throws IOException
     {
         return getText().length();
     }
 
     @Override
     public int getTextOffset()
-            throws IOException, JsonParseException
     {
         return 0;
     }
 
     @Override
     public byte[] getBinaryValue(Base64Variant b64variant)
-            throws IOException, JsonParseException
     {
         switch (type) {
             case BYTES:
@@ -449,7 +397,6 @@ public byte[] getBinaryValue(Base64Variant b64variant)
 
     @Override
     public Number getNumberValue()
-            throws IOException, JsonParseException
     {
         switch (type) {
             case INT:
@@ -467,7 +414,6 @@ public Number getNumberValue()
 
     @Override
     public int getIntValue()
-            throws IOException, JsonParseException
     {
         switch (type) {
             case INT:
@@ -485,7 +431,6 @@ public int getIntValue()
 
     @Override
     public long getLongValue()
-            throws IOException, JsonParseException
     {
         switch (type) {
             case INT:
@@ -503,7 +448,6 @@ public long getLongValue()
 
     @Override
     public BigInteger getBigIntegerValue()
-            throws IOException, JsonParseException
     {
         switch (type) {
             case INT:
@@ -521,7 +465,6 @@ public BigInteger getBigIntegerValue()
 
     @Override
     public float getFloatValue()
-            throws IOException, JsonParseException
     {
         switch (type) {
             case INT:
@@ -539,11 +482,10 @@ public float getFloatValue()
 
     @Override
     public double getDoubleValue()
-            throws IOException, JsonParseException
     {
          switch (type) {
              case INT:
-                 return (double) intValue;
+                 return intValue;
             case LONG:
                 return (double) longValue;
             case DOUBLE:
@@ -557,7 +499,6 @@ public double getDoubleValue()
 
     @Override
     public BigDecimal getDecimalValue()
-            throws IOException
     {
          switch (type) {
              case INT:
@@ -586,8 +527,7 @@ private Object deserializedExtensionTypeValue()
     }
 
     @Override
-    public Object getEmbeddedObject()
-            throws IOException, JsonParseException
+    public Object getEmbeddedObject() throws IOException
     {
         switch (type) {
             case BYTES:
@@ -601,7 +541,6 @@ public Object getEmbeddedObject()
 
     @Override
     public NumberType getNumberType()
-            throws IOException, JsonParseException
     {
         switch (type) {
             case INT:
@@ -623,7 +562,6 @@ public void close()
     {
         try {
             if (isEnabled(JsonParser.Feature.AUTO_CLOSE_SOURCE)) {
-                MessageUnpacker messageUnpacker = getMessageUnpacker();
                 messageUnpacker.close();
             }
         }
@@ -641,59 +579,72 @@ public boolean isClosed()
     @Override
     public JsonStreamContext getParsingContext()
     {
-        return parsingContext;
+        return streamReadContext;
     }
 
     @Override
+    public JsonLocation currentTokenLocation()
+    {
+        return new JsonLocation(ioContext.contentReference(), tokenPosition, -1, -1);
+    }
+
+    @Override
+    public JsonLocation currentLocation()
+    {
+        return new JsonLocation(ioContext.contentReference(), currentPosition, -1, -1);
+    }
+
+    @Override
+    @Deprecated
     public JsonLocation getTokenLocation()
     {
-        return new JsonLocation(ioContext.getSourceReference(), tokenPosition, -1, -1, (int) tokenPosition);
+        return currentTokenLocation();
     }
 
     @Override
+    @Deprecated
     public JsonLocation getCurrentLocation()
     {
-        return new JsonLocation(ioContext.getSourceReference(), currentPosition, -1, -1, (int) currentPosition);
+        return currentLocation();
     }
 
     @Override
     public void overrideCurrentName(String name)
     {
+        // Simple, but need to look for START_OBJECT/ARRAY's "off-by-one" thing:
+        MessagePackReadContext ctxt = streamReadContext;
+        if (_currToken == JsonToken.START_OBJECT || _currToken == JsonToken.START_ARRAY) {
+            ctxt = ctxt.getParent();
+        }
+        // Unfortunate, but since we did not expose exceptions, need to wrap
         try {
-            if (_currToken == JsonToken.START_OBJECT || _currToken == JsonToken.START_ARRAY) {
-                JsonReadContext parent = parsingContext.getParent();
-                parent.setCurrentName(name);
-            }
-            else {
-                parsingContext.setCurrentName(name);
-            }
+            ctxt.setCurrentName(name);
         }
-        catch (JsonProcessingException e) {
+        catch (IOException e) {
             throw new IllegalStateException(e);
         }
     }
 
     @Override
-    public String getCurrentName()
-            throws IOException
+    public String currentName()
     {
         if (_currToken == JsonToken.START_OBJECT || _currToken == JsonToken.START_ARRAY) {
-            JsonReadContext parent = parsingContext.getParent();
+            MessagePackReadContext parent = streamReadContext.getParent();
             return parent.getCurrentName();
         }
-        return parsingContext.getCurrentName();
+        return streamReadContext.getCurrentName();
     }
 
-    private MessageUnpacker getMessageUnpacker()
+    public boolean isCurrentFieldId()
     {
-        if (!reuseResourceInParser) {
-            return this.messageUnpacker;
-        }
+        return this.type == Type.INT || this.type == Type.LONG;
+    }
 
-        Tuple<Object, MessageUnpacker> messageUnpackerTuple = messageUnpackerHolder.get();
-        if (messageUnpackerTuple == null) {
-            throw new IllegalStateException("messageUnpacker is null");
-        }
-        return messageUnpackerTuple.second();
+    @Override
+    @Deprecated
+    public String getCurrentName()
+            throws IOException
+    {
+        return currentName();
     }
 }
diff --git a/msgpack-jackson/src/main/java/org/msgpack/jackson/dataformat/MessagePackReadContext.java b/msgpack-jackson/src/main/java/org/msgpack/jackson/dataformat/MessagePackReadContext.java
new file mode 100644
index 000000000..403f1b368
--- /dev/null
+++ b/msgpack-jackson/src/main/java/org/msgpack/jackson/dataformat/MessagePackReadContext.java
@@ -0,0 +1,269 @@
+package org.msgpack.jackson.dataformat;
+
+import com.fasterxml.jackson.core.JsonLocation;
+import com.fasterxml.jackson.core.JsonParseException;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.core.JsonStreamContext;
+import com.fasterxml.jackson.core.io.CharTypes;
+import com.fasterxml.jackson.core.io.ContentReference;
+import com.fasterxml.jackson.core.json.DupDetector;
+
+/**
+ * Replacement of {@link com.fasterxml.jackson.core.json.JsonReadContext}
+ * to support features needed by MessagePack format.
+ */
+public final class MessagePackReadContext
+    extends JsonStreamContext
+{
+    /**
+     * Parent context for this context; null for root context.
+     */
+    protected final MessagePackReadContext parent;
+
+    // // // Optional duplicate detection
+
+    protected final DupDetector dups;
+
+    /**
+     * For fixed-size Arrays, Objects, this indicates expected number of entries.
+     */
+    protected int expEntryCount;
+
+    // // // Location information (minus source reference)
+
+    protected String currentName;
+
+    protected Object currentValue;
+
+    /*
+    /**********************************************************
+    /* Simple instance reuse slots
+    /**********************************************************
+     */
+
+    protected MessagePackReadContext child = null;
+
+    /*
+    /**********************************************************
+    /* Instance construction, reuse
+    /**********************************************************
+     */
+
+    public MessagePackReadContext(MessagePackReadContext parent, DupDetector dups,
+                                  int type, int expEntryCount)
+    {
+        super();
+        this.parent = parent;
+        this.dups = dups;
+        _type = type;
+        this.expEntryCount = expEntryCount;
+        _index = -1;
+        _nestingDepth = parent == null ? 0 : parent._nestingDepth + 1;
+    }
+
+    protected void reset(int type, int expEntryCount)
+    {
+        _type = type;
+        this.expEntryCount = expEntryCount;
+        _index = -1;
+        currentName = null;
+        currentValue = null;
+        if (dups != null) {
+            dups.reset();
+        }
+    }
+
+    @Override
+    public Object getCurrentValue()
+    {
+        return currentValue;
+    }
+
+    @Override
+    public void setCurrentValue(Object v)
+    {
+        currentValue = v;
+    }
+
+    // // // Factory methods
+
+    public static MessagePackReadContext createRootContext(DupDetector dups)
+    {
+        return new MessagePackReadContext(null, dups, TYPE_ROOT, -1);
+    }
+
+    public MessagePackReadContext createChildArrayContext(int expEntryCount)
+    {
+        MessagePackReadContext ctxt = child;
+        if (ctxt == null) {
+            ctxt = new MessagePackReadContext(this,
+                    (dups == null) ? null : dups.child(),
+                            TYPE_ARRAY, expEntryCount);
+            child = ctxt;
+        }
+        else {
+            ctxt.reset(TYPE_ARRAY, expEntryCount);
+        }
+        return ctxt;
+    }
+
+    public MessagePackReadContext createChildObjectContext(int expEntryCount)
+    {
+        MessagePackReadContext ctxt = child;
+        if (ctxt == null) {
+            ctxt = new MessagePackReadContext(this,
+                    (dups == null) ? null : dups.child(),
+                    TYPE_OBJECT, expEntryCount);
+            child = ctxt;
+            return ctxt;
+        }
+        ctxt.reset(TYPE_OBJECT, expEntryCount);
+        return ctxt;
+    }
+
+    /*
+    /**********************************************************
+    /* Abstract method implementation
+    /**********************************************************
+     */
+
+    @Override
+    public String getCurrentName()
+    {
+        return currentName;
+    }
+
+    @Override
+    public MessagePackReadContext getParent()
+    {
+        return parent;
+    }
+
+    /*
+    /**********************************************************
+    /* Extended API
+    /**********************************************************
+     */
+
+    public boolean hasExpectedLength()
+    {
+        return (expEntryCount >= 0);
+    }
+
+    public int getExpectedLength()
+    {
+        return expEntryCount;
+    }
+
+    public boolean isEmpty()
+    {
+        return expEntryCount == 0;
+    }
+
+    public int getRemainingExpectedLength()
+    {
+        int diff = expEntryCount - _index;
+        // Negative values would occur when expected count is -1
+        return Math.max(0, diff);
+    }
+
+    public boolean acceptsBreakMarker()
+    {
+        return (expEntryCount < 0) && _type != TYPE_ROOT;
+    }
+
+    /**
+     * Method called to increment the current entry count (Object property, Array
+     * element or Root value) for this context level
+     * and then see if more entries are accepted.
+     * The only case where more entries are NOT expected is for fixed-count
+     * Objects and Arrays that just reached the entry count.
+     *<p>
+     * Note that since the entry count is updated this is a state-changing method.
+     */
+    public boolean expectMoreValues()
+    {
+        if (++_index == expEntryCount) {
+            return false;
+        }
+        return true;
+    }
+
+    /**
+     * @return Location pointing to the point where the context
+     *   start marker was found
+     */
+    @Override
+    public JsonLocation startLocation(ContentReference srcRef)
+    {
+        return new JsonLocation(srcRef, 1L, -1, -1);
+    }
+
+    @Override
+    @Deprecated // since 2.13
+    public JsonLocation getStartLocation(Object rawSrc)
+    {
+        return startLocation(ContentReference.rawReference(rawSrc));
+    }
+
+    /*
+    /**********************************************************
+    /* State changes
+    /**********************************************************
+     */
+
+    public void setCurrentName(String name) throws JsonProcessingException
+    {
+        currentName = name;
+        if (dups != null) {
+            _checkDup(dups, name);
+        }
+    }
+
+    private void _checkDup(DupDetector dd, String name) throws JsonProcessingException
+    {
+        if (dd.isDup(name)) {
+            throw new JsonParseException(null,
+                    "Duplicate field '" + name + "'", dd.findLocation());
+        }
+    }
+
+    /*
+    /**********************************************************
+    /* Overridden standard methods
+    /**********************************************************
+     */
+
+    /**
+     * Overridden to provide developer readable "JsonPath" representation
+     * of the context.
+     */
+    @Override
+    public String toString()
+    {
+        StringBuilder sb = new StringBuilder(64);
+        switch (_type) {
+        case TYPE_ROOT:
+            sb.append("/");
+            break;
+        case TYPE_ARRAY:
+            sb.append('[');
+            sb.append(getCurrentIndex());
+            sb.append(']');
+            break;
+        case TYPE_OBJECT:
+            sb.append('{');
+            if (currentName != null) {
+                sb.append('"');
+                CharTypes.appendQuoted(sb, currentName);
+                sb.append('"');
+            }
+            else {
+                sb.append('?');
+            }
+            sb.append('}');
+            break;
+        }
+        return sb.toString();
+    }
+}
diff --git a/msgpack-jackson/src/main/java/org/msgpack/jackson/dataformat/MessagePackSerializedString.java b/msgpack-jackson/src/main/java/org/msgpack/jackson/dataformat/MessagePackSerializedString.java
index c7c65ff2b..72ed5d8de 100644
--- a/msgpack-jackson/src/main/java/org/msgpack/jackson/dataformat/MessagePackSerializedString.java
+++ b/msgpack-jackson/src/main/java/org/msgpack/jackson/dataformat/MessagePackSerializedString.java
@@ -17,15 +17,15 @@
 
 import com.fasterxml.jackson.core.SerializableString;
 
-import java.io.IOException;
 import java.io.OutputStream;
 import java.nio.ByteBuffer;
 import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
 
 public class MessagePackSerializedString
         implements SerializableString
 {
-    private static final Charset UTF8 = Charset.forName("UTF-8");
+    private static final Charset UTF8 = StandardCharsets.UTF_8;
     private final Object value;
 
     public MessagePackSerializedString(Object value)
@@ -89,28 +89,24 @@ public int appendUnquoted(char[] chars, int i)
 
     @Override
     public int writeQuotedUTF8(OutputStream outputStream)
-            throws IOException
     {
         return 0;
     }
 
     @Override
     public int writeUnquotedUTF8(OutputStream outputStream)
-            throws IOException
     {
         return 0;
     }
 
     @Override
     public int putQuotedUTF8(ByteBuffer byteBuffer)
-            throws IOException
     {
         return 0;
     }
 
     @Override
     public int putUnquotedUTF8(ByteBuffer byteBuffer)
-            throws IOException
     {
         return 0;
     }
diff --git a/msgpack-jackson/src/main/java/org/msgpack/jackson/dataformat/MessagePackSerializerFactory.java b/msgpack-jackson/src/main/java/org/msgpack/jackson/dataformat/MessagePackSerializerFactory.java
index fa2148dc0..4100ef4cc 100644
--- a/msgpack-jackson/src/main/java/org/msgpack/jackson/dataformat/MessagePackSerializerFactory.java
+++ b/msgpack-jackson/src/main/java/org/msgpack/jackson/dataformat/MessagePackSerializerFactory.java
@@ -16,8 +16,10 @@
 package org.msgpack.jackson.dataformat;
 
 import com.fasterxml.jackson.databind.JavaType;
+import com.fasterxml.jackson.databind.JsonMappingException;
 import com.fasterxml.jackson.databind.JsonSerializer;
 import com.fasterxml.jackson.databind.SerializationConfig;
+import com.fasterxml.jackson.databind.SerializerProvider;
 import com.fasterxml.jackson.databind.cfg.SerializerFactoryConfig;
 import com.fasterxml.jackson.databind.ser.BeanSerializerFactory;
 
@@ -43,6 +45,13 @@ public MessagePackSerializerFactory(SerializerFactoryConfig config)
     }
 
     @Override
+    public JsonSerializer<Object> createKeySerializer(SerializerProvider prov, JavaType keyType, JsonSerializer<Object> defaultImpl) throws JsonMappingException
+    {
+        return new MessagePackKeySerializer();
+    }
+
+    @Override
+    @Deprecated
     public JsonSerializer<Object> createKeySerializer(SerializationConfig config, JavaType keyType, JsonSerializer<Object> defaultImpl)
     {
         return new MessagePackKeySerializer();
diff --git a/msgpack-jackson/src/main/java/org/msgpack/jackson/dataformat/TimestampExtensionModule.java b/msgpack-jackson/src/main/java/org/msgpack/jackson/dataformat/TimestampExtensionModule.java
new file mode 100755
index 000000000..2216d2769
--- /dev/null
+++ b/msgpack-jackson/src/main/java/org/msgpack/jackson/dataformat/TimestampExtensionModule.java
@@ -0,0 +1,82 @@
+package org.msgpack.jackson.dataformat;
+
+import com.fasterxml.jackson.core.JsonGenerator;
+import com.fasterxml.jackson.core.JsonParser;
+import com.fasterxml.jackson.databind.DeserializationContext;
+import com.fasterxml.jackson.databind.SerializerProvider;
+import com.fasterxml.jackson.databind.deser.std.StdDeserializer;
+import com.fasterxml.jackson.databind.module.SimpleModule;
+import com.fasterxml.jackson.databind.ser.std.StdSerializer;
+import org.msgpack.core.ExtensionTypeHeader;
+import org.msgpack.core.MessagePack;
+import org.msgpack.core.MessagePacker;
+import org.msgpack.core.MessageUnpacker;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.time.Instant;
+
+public class TimestampExtensionModule
+{
+    public static final byte EXT_TYPE = -1;
+    public static final SimpleModule INSTANCE = new SimpleModule("msgpack-ext-timestamp");
+
+    static {
+        INSTANCE.addSerializer(Instant.class, new InstantSerializer(Instant.class));
+        INSTANCE.addDeserializer(Instant.class, new InstantDeserializer(Instant.class));
+    }
+
+    private static class InstantSerializer extends StdSerializer<Instant>
+    {
+        protected InstantSerializer(Class<Instant> t)
+        {
+            super(t);
+        }
+
+        @Override
+        public void serialize(Instant value, JsonGenerator gen, SerializerProvider provider)
+            throws IOException
+        {
+            ByteArrayOutputStream os = new ByteArrayOutputStream();
+            // MEMO: Reusing these MessagePacker and MessageUnpacker instances would improve the performance
+            try (MessagePacker packer = MessagePack.newDefaultPacker(os)) {
+                packer.packTimestamp(value);
+            }
+            try (MessageUnpacker unpacker = MessagePack.newDefaultUnpacker(os.toByteArray())) {
+                ExtensionTypeHeader header = unpacker.unpackExtensionTypeHeader();
+                byte[] bytes = unpacker.readPayload(header.getLength());
+
+                MessagePackExtensionType extensionType = new MessagePackExtensionType(EXT_TYPE, bytes);
+                gen.writeObject(extensionType);
+            }
+        }
+    }
+
+    private static class InstantDeserializer extends StdDeserializer<Instant>
+    {
+        protected InstantDeserializer(Class<?> vc)
+        {
+            super(vc);
+        }
+
+        @Override
+        public Instant deserialize(JsonParser p, DeserializationContext ctxt)
+            throws IOException
+        {
+            MessagePackExtensionType ext = p.readValueAs(MessagePackExtensionType.class);
+            if (ext.getType() != EXT_TYPE) {
+                throw new RuntimeException(
+                        String.format("Unexpected extension type (0x%X) for Instant object", ext.getType()));
+            }
+
+            // MEMO: Reusing this MessageUnpacker instance would improve the performance
+            try (MessageUnpacker unpacker = MessagePack.newDefaultUnpacker(ext.getData())) {
+                return unpacker.unpackTimestamp(new ExtensionTypeHeader(EXT_TYPE, ext.getData().length));
+            }
+        }
+    }
+
+    private TimestampExtensionModule()
+    {
+    }
+}
diff --git a/msgpack-jackson/src/test/java/org/msgpack/jackson/dataformat/MessagePackDataformatForFieldIdTest.java b/msgpack-jackson/src/test/java/org/msgpack/jackson/dataformat/MessagePackDataformatForFieldIdTest.java
new file mode 100644
index 000000000..bbac6fb96
--- /dev/null
+++ b/msgpack-jackson/src/test/java/org/msgpack/jackson/dataformat/MessagePackDataformatForFieldIdTest.java
@@ -0,0 +1,132 @@
+//
+// MessagePack for Java
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+package org.msgpack.jackson.dataformat;
+
+import com.fasterxml.jackson.core.JsonParser;
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.DeserializationContext;
+import com.fasterxml.jackson.databind.JsonDeserializer;
+import com.fasterxml.jackson.databind.KeyDeserializer;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.deser.NullValueProvider;
+import com.fasterxml.jackson.databind.deser.impl.JDKValueInstantiators;
+import com.fasterxml.jackson.databind.deser.std.MapDeserializer;
+import com.fasterxml.jackson.databind.jsontype.TypeDeserializer;
+import com.fasterxml.jackson.databind.module.SimpleModule;
+import com.fasterxml.jackson.databind.type.TypeFactory;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.LinkedHashMap;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class MessagePackDataformatForFieldIdTest
+{
+    static class MessagePackMapDeserializer extends MapDeserializer
+    {
+        public static KeyDeserializer keyDeserializer = new KeyDeserializer()
+        {
+            @Override
+            public Object deserializeKey(String s, DeserializationContext deserializationContext)
+                    throws IOException
+            {
+                JsonParser parser = deserializationContext.getParser();
+                if (parser instanceof MessagePackParser) {
+                    MessagePackParser p = (MessagePackParser) parser;
+                    if (p.isCurrentFieldId()) {
+                        return Integer.valueOf(s);
+                    }
+                }
+                return s;
+            }
+        };
+
+        public MessagePackMapDeserializer()
+        {
+            super(
+                    TypeFactory.defaultInstance().constructMapType(Map.class, Object.class, Object.class),
+                    JDKValueInstantiators.findStdValueInstantiator(null, LinkedHashMap.class),
+                    keyDeserializer, null, null);
+        }
+
+        public MessagePackMapDeserializer(MapDeserializer src, KeyDeserializer keyDeser,
+                JsonDeserializer<Object> valueDeser, TypeDeserializer valueTypeDeser, NullValueProvider nuller,
+                Set<String> ignorable, Set<String> includable)
+        {
+            super(src, keyDeser, valueDeser, valueTypeDeser, nuller, ignorable, includable);
+        }
+
+        @Override
+        protected MapDeserializer withResolved(KeyDeserializer keyDeser, TypeDeserializer valueTypeDeser,
+                JsonDeserializer<?> valueDeser, NullValueProvider nuller, Set<String> ignorable,
+                Set<String> includable)
+        {
+            return new MessagePackMapDeserializer(this, keyDeser, (JsonDeserializer<Object>) valueDeser, valueTypeDeser,
+                    nuller, ignorable, includable);
+        }
+    }
+
+    @Test
+    public void testMixedKeys()
+            throws IOException
+    {
+        ObjectMapper mapper = new ObjectMapper(
+                    new MessagePackFactory()
+                        .setSupportIntegerKeys(true)
+                )
+                .registerModule(new SimpleModule()
+                .addDeserializer(Map.class, new MessagePackMapDeserializer()));
+
+        Map<Object, Object> map = new HashMap<>();
+        map.put(1, "one");
+        map.put("2", "two");
+
+        byte[] bytes = mapper.writeValueAsBytes(map);
+        Map<Object, Object> deserializedInit = mapper.readValue(bytes, new TypeReference<Map<Object, Object>>() {});
+
+        Map<Object, Object> expected = new HashMap<>(map);
+        Map<Object, Object> actual = new HashMap<>(deserializedInit);
+
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void testMixedKeysBackwardsCompatiable()
+            throws IOException
+    {
+        ObjectMapper mapper = new ObjectMapper(new MessagePackFactory())
+                .registerModule(new SimpleModule()
+                .addDeserializer(Map.class, new MessagePackMapDeserializer()));
+
+        Map<Object, Object> map = new HashMap<>();
+        map.put(1, "one");
+        map.put("2", "two");
+
+        byte[] bytes = mapper.writeValueAsBytes(map);
+        Map<Object, Object> deserializedInit = mapper.readValue(bytes, new TypeReference<Map<Object, Object>>() {});
+
+        Map<Object, Object> expected = new HashMap<>();
+        expected.put("1", "one");
+        expected.put("2", "two");
+        Map<Object, Object> actual = new HashMap<>(deserializedInit);
+
+        assertEquals(expected, actual);
+    }
+}
diff --git a/msgpack-jackson/src/test/java/org/msgpack/jackson/dataformat/MessagePackDataformatForPojoTest.java b/msgpack-jackson/src/test/java/org/msgpack/jackson/dataformat/MessagePackDataformatForPojoTest.java
index c6b020686..e899e4f4a 100644
--- a/msgpack-jackson/src/test/java/org/msgpack/jackson/dataformat/MessagePackDataformatForPojoTest.java
+++ b/msgpack-jackson/src/test/java/org/msgpack/jackson/dataformat/MessagePackDataformatForPojoTest.java
@@ -16,7 +16,7 @@
 package org.msgpack.jackson.dataformat;
 
 import com.fasterxml.jackson.databind.ObjectMapper;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.io.IOException;
 import java.nio.charset.Charset;
@@ -24,9 +24,9 @@
 import static org.hamcrest.CoreMatchers.not;
 import static org.hamcrest.CoreMatchers.containsString;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertThat;
-import static org.junit.Assert.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.hamcrest.MatcherAssert.assertThat;
 
 public class MessagePackDataformatForPojoTest
         extends MessagePackDataformatTestBase
@@ -46,6 +46,7 @@ public void testNormal()
         assertArrayEquals(normalPojo.b, value.b);
         assertEquals(normalPojo.bi, value.bi);
         assertEquals(normalPojo.suit, Suit.HEART);
+        assertEquals(normalPojo.sMultibyte, value.sMultibyte);
     }
 
     @Test
@@ -59,13 +60,38 @@ public void testNestedList()
     }
 
     @Test
-    public void testNestedListComplex()
+    public void testNestedListComplex1()
             throws IOException
     {
-        byte[] bytes = objectMapper.writeValueAsBytes(nestedListComplexPojo);
-        NestedListComplexPojo value = objectMapper.readValue(bytes, NestedListComplexPojo.class);
-        assertEquals(nestedListPojo.s, value.s);
-        assertEquals(nestedListComplexPojo.foos.get(0).t, value.foos.get(0).t);
+        byte[] bytes = objectMapper.writeValueAsBytes(nestedListComplexPojo1);
+        NestedListComplexPojo1 value = objectMapper.readValue(bytes, NestedListComplexPojo1.class);
+        assertEquals(nestedListComplexPojo1.s, value.s);
+        assertEquals(1, nestedListComplexPojo1.foos.size());
+        assertEquals(nestedListComplexPojo1.foos.get(0).t, value.foos.get(0).t);
+    }
+
+    @Test
+    public void testNestedListComplex2()
+            throws IOException
+    {
+        byte[] bytes = objectMapper.writeValueAsBytes(nestedListComplexPojo2);
+        NestedListComplexPojo2 value = objectMapper.readValue(bytes, NestedListComplexPojo2.class);
+        assertEquals(nestedListComplexPojo2.s, value.s);
+        assertEquals(2, nestedListComplexPojo2.foos.size());
+        assertEquals(nestedListComplexPojo2.foos.get(0).t, value.foos.get(0).t);
+        assertEquals(nestedListComplexPojo2.foos.get(1).t, value.foos.get(1).t);
+    }
+
+    @Test
+    public void testStrings()
+            throws IOException
+    {
+        byte[] bytes = objectMapper.writeValueAsBytes(stringPojo);
+        StringPojo value = objectMapper.readValue(bytes, StringPojo.class);
+        assertEquals(stringPojo.shortSingleByte, value.shortSingleByte);
+        assertEquals(stringPojo.longSingleByte, value.longSingleByte);
+        assertEquals(stringPojo.shortMultiByte, value.shortMultiByte);
+        assertEquals(stringPojo.longMultiByte, value.longMultiByte);
     }
 
     @Test
diff --git a/msgpack-jackson/src/test/java/org/msgpack/jackson/dataformat/MessagePackDataformatTestBase.java b/msgpack-jackson/src/test/java/org/msgpack/jackson/dataformat/MessagePackDataformatTestBase.java
index d2d3d456a..b9ef4cf3d 100644
--- a/msgpack-jackson/src/test/java/org/msgpack/jackson/dataformat/MessagePackDataformatTestBase.java
+++ b/msgpack-jackson/src/test/java/org/msgpack/jackson/dataformat/MessagePackDataformatTestBase.java
@@ -43,7 +43,9 @@ public class MessagePackDataformatTestBase
     protected ObjectMapper objectMapper;
     protected NormalPojo normalPojo;
     protected NestedListPojo nestedListPojo;
-    protected NestedListComplexPojo nestedListComplexPojo;
+    protected NestedListComplexPojo1 nestedListComplexPojo1;
+    protected NestedListComplexPojo2 nestedListComplexPojo2;
+    protected StringPojo stringPojo;
     protected TinyPojo tinyPojo;
     protected ComplexPojo complexPojo;
 
@@ -65,18 +67,31 @@ public void setup()
         normalPojo.b = new byte[] {0x01, 0x02, (byte) 0xFE, (byte) 0xFF};
         normalPojo.bi = BigInteger.valueOf(Long.MAX_VALUE).add(BigInteger.ONE);
         normalPojo.suit = Suit.HEART;
+        normalPojo.sMultibyte = "text文字";
 
         nestedListPojo = new NestedListPojo();
         nestedListPojo.s = "a string";
-        nestedListPojo.strs = Arrays.asList("string", "another string", "another string");
+        nestedListPojo.strs = Arrays.asList("string#1", "string#2", "string#3");
 
         tinyPojo = new TinyPojo();
         tinyPojo.t = "t string";
 
-        nestedListComplexPojo = new NestedListComplexPojo();
-        nestedListComplexPojo.s = "a string";
-        nestedListComplexPojo.foos = new ArrayList<TinyPojo>();
-        nestedListComplexPojo.foos.add(tinyPojo);
+        nestedListComplexPojo1 = new NestedListComplexPojo1();
+        nestedListComplexPojo1.s = "a string";
+        nestedListComplexPojo1.foos = new ArrayList<>();
+        nestedListComplexPojo1.foos.add(tinyPojo);
+
+        nestedListComplexPojo2 = new NestedListComplexPojo2();
+        nestedListComplexPojo2.foos = new ArrayList<>();
+        nestedListComplexPojo2.foos.add(tinyPojo);
+        nestedListComplexPojo2.foos.add(tinyPojo);
+        nestedListComplexPojo2.s = "another string";
+
+        stringPojo = new StringPojo();
+        stringPojo.shortSingleByte = "hello";
+        stringPojo.longSingleByte = "helloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworld";
+        stringPojo.shortMultiByte = "こんにちは";
+        stringPojo.longMultiByte = "こんにちは、世界！！こんにちは、世界！！こんにちは、世界！！こんにちは、世界！！こんにちは、世界！！";
 
         complexPojo = new ComplexPojo();
         complexPojo.name = "komamitsu";
@@ -131,12 +146,26 @@ public static class TinyPojo
         public String t;
     }
 
-    public static class NestedListComplexPojo
+    public static class NestedListComplexPojo1
     {
         public String s;
         public List<TinyPojo> foos;
     }
 
+    public static class NestedListComplexPojo2
+    {
+        public List<TinyPojo> foos;
+        public String s;
+    }
+
+    public static class StringPojo
+    {
+        public String shortSingleByte;
+        public String longSingleByte;
+        public String shortMultiByte;
+        public String longMultiByte;
+    }
+
     public static class NormalPojo
     {
         String s;
@@ -148,6 +177,7 @@ public static class NormalPojo
         public byte[] b;
         public BigInteger bi;
         public Suit suit;
+        public String sMultibyte;
 
         public String getS()
         {
diff --git a/msgpack-jackson/src/test/java/org/msgpack/jackson/dataformat/MessagePackFactoryTest.java b/msgpack-jackson/src/test/java/org/msgpack/jackson/dataformat/MessagePackFactoryTest.java
index f8d7ac3c8..9e3765417 100644
--- a/msgpack-jackson/src/test/java/org/msgpack/jackson/dataformat/MessagePackFactoryTest.java
+++ b/msgpack-jackson/src/test/java/org/msgpack/jackson/dataformat/MessagePackFactoryTest.java
@@ -23,7 +23,7 @@
 import com.fasterxml.jackson.databind.AnnotationIntrospector;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.introspect.JacksonAnnotationIntrospector;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.msgpack.core.MessagePack;
 
 import java.io.IOException;
@@ -35,8 +35,8 @@
 import static org.hamcrest.CoreMatchers.is;
 import static org.hamcrest.CoreMatchers.notNullValue;
 import static org.hamcrest.CoreMatchers.nullValue;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.hamcrest.MatcherAssert.assertThat;
 
 public class MessagePackFactoryTest
         extends MessagePackDataformatTestBase
diff --git a/msgpack-jackson/src/test/java/org/msgpack/jackson/dataformat/MessagePackGeneratorTest.java b/msgpack-jackson/src/test/java/org/msgpack/jackson/dataformat/MessagePackGeneratorTest.java
index e2c202bc3..a13951b23 100644
--- a/msgpack-jackson/src/test/java/org/msgpack/jackson/dataformat/MessagePackGeneratorTest.java
+++ b/msgpack-jackson/src/test/java/org/msgpack/jackson/dataformat/MessagePackGeneratorTest.java
@@ -24,7 +24,7 @@
 import com.fasterxml.jackson.databind.SerializerProvider;
 import com.fasterxml.jackson.databind.annotation.JsonSerialize;
 import com.fasterxml.jackson.databind.module.SimpleModule;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.msgpack.core.ExtensionTypeHeader;
 import org.msgpack.core.MessagePack;
 import org.msgpack.core.MessageUnpacker;
@@ -40,6 +40,7 @@
 import java.math.BigDecimal;
 import java.math.BigInteger;
 import java.nio.ByteBuffer;
+import java.nio.file.Files;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;
@@ -52,13 +53,14 @@
 import java.util.concurrent.TimeUnit;
 
 import static org.hamcrest.CoreMatchers.is;
-import static org.junit.Assert.assertArrayEquals;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotEquals;
-import static org.junit.Assert.assertThat;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.hamcrest.MatcherAssert.assertThat;
 
 public class MessagePackGeneratorTest
         extends MessagePackDataformatTestBase
@@ -283,6 +285,8 @@ public void testWritePrimitives()
         generator.writeNumber(0);
         generator.writeString("one");
         generator.writeNumber(2.0f);
+        generator.writeString("三");
+        generator.writeString("444④");
         generator.flush();
         generator.close();
 
@@ -291,6 +295,8 @@ public void testWritePrimitives()
         assertEquals(0, unpacker.unpackInt());
         assertEquals("one", unpacker.unpackString());
         assertEquals(2.0f, unpacker.unpackFloat(), 0.001f);
+        assertEquals("三", unpacker.unpackString());
+        assertEquals("444④", unpacker.unpackString());
         assertFalse(unpacker.hasNext());
     }
 
@@ -344,7 +350,7 @@ public void testBigDecimal()
         }
     }
 
-    @Test(expected = IOException.class)
+    @Test
     public void testEnableFeatureAutoCloseTarget()
             throws IOException
     {
@@ -353,7 +359,9 @@ public void testEnableFeatureAutoCloseTarget()
         ObjectMapper objectMapper = new ObjectMapper(messagePackFactory);
         List<Integer> integers = Arrays.asList(1);
         objectMapper.writeValue(out, integers);
-        objectMapper.writeValue(out, integers);
+        assertThrows(IOException.class, () -> {
+            objectMapper.writeValue(out, integers);
+        });
     }
 
     @Test
@@ -382,23 +390,24 @@ public void testWritePrimitiveObjectViaObjectMapper()
             throws Exception
     {
         File tempFile = createTempFile();
-        OutputStream out = new FileOutputStream(tempFile);
-
-        ObjectMapper objectMapper = new ObjectMapper(new MessagePackFactory());
-        objectMapper.configure(JsonGenerator.Feature.AUTO_CLOSE_TARGET, false);
-        objectMapper.writeValue(out, 1);
-        objectMapper.writeValue(out, "two");
-        objectMapper.writeValue(out, 3.14);
-        objectMapper.writeValue(out, Arrays.asList(4));
-        objectMapper.writeValue(out, 5L);
-
-        MessageUnpacker unpacker = MessagePack.newDefaultUnpacker(new FileInputStream(tempFile));
-        assertEquals(1, unpacker.unpackInt());
-        assertEquals("two", unpacker.unpackString());
-        assertEquals(3.14, unpacker.unpackFloat(), 0.0001);
-        assertEquals(1, unpacker.unpackArrayHeader());
-        assertEquals(4, unpacker.unpackInt());
-        assertEquals(5, unpacker.unpackLong());
+        try (OutputStream out = Files.newOutputStream(tempFile.toPath())) {
+            ObjectMapper objectMapper = new ObjectMapper(new MessagePackFactory());
+            objectMapper.configure(JsonGenerator.Feature.AUTO_CLOSE_TARGET, false);
+            objectMapper.writeValue(out, 1);
+            objectMapper.writeValue(out, "two");
+            objectMapper.writeValue(out, 3.14);
+            objectMapper.writeValue(out, Arrays.asList(4));
+            objectMapper.writeValue(out, 5L);
+        }
+
+        try (MessageUnpacker unpacker = MessagePack.newDefaultUnpacker(new FileInputStream(tempFile))) {
+            assertEquals(1, unpacker.unpackInt());
+            assertEquals("two", unpacker.unpackString());
+            assertEquals(3.14, unpacker.unpackFloat(), 0.0001);
+            assertEquals(1, unpacker.unpackArrayHeader());
+            assertEquals(4, unpacker.unpackInt());
+            assertEquals(5, unpacker.unpackLong());
+        }
     }
 
     @Test
@@ -442,10 +451,11 @@ public Exception call()
                 throw exception;
             }
             else {
-                ByteArrayOutputStream outputStream = buffers.get(ti);
-                MessageUnpacker unpacker = MessagePack.newDefaultUnpacker(outputStream.toByteArray());
-                for (int i = 0; i < loopCount; i++) {
-                    assertEquals(ti, unpacker.unpackInt());
+                try (ByteArrayOutputStream outputStream = buffers.get(ti);
+                MessageUnpacker unpacker = MessagePack.newDefaultUnpacker(outputStream.toByteArray())) {
+                    for (int i = 0; i < loopCount; i++) {
+                        assertEquals(ti, unpacker.unpackInt());
+                    }
                 }
             }
         }
@@ -663,7 +673,9 @@ public void testNonStringKey()
 
             ObjectMapper objectMapper = new ObjectMapper(new MessagePackFactory());
             if (mapHolder instanceof NonStringKeyMapHolderWithoutAnnotation) {
-                objectMapper.setSerializerFactory(new MessagePackSerializerFactory());
+                SimpleModule mod = new SimpleModule("test");
+                mod.addKeySerializer(Object.class, new MessagePackKeySerializer());
+                objectMapper.registerModule(mod);
             }
 
             byte[] bytes = objectMapper.writeValueAsBytes(mapHolder);
@@ -709,7 +721,9 @@ public void testComplexTypeKey()
         map.put(pojo, 42);
 
         ObjectMapper objectMapper = new ObjectMapper(new MessagePackFactory());
-        objectMapper.setSerializerFactory(new MessagePackSerializerFactory());
+        SimpleModule mod = new SimpleModule("test");
+        mod.addKeySerializer(TinyPojo.class, new MessagePackKeySerializer());
+        objectMapper.registerModule(mod);
         byte[] bytes = objectMapper.writeValueAsBytes(map);
 
         MessageUnpacker unpacker = MessagePack.newDefaultUnpacker(bytes);
@@ -731,7 +745,9 @@ public void testComplexTypeKeyWithV06Format()
 
         ObjectMapper objectMapper = new ObjectMapper(new MessagePackFactory());
         objectMapper.setAnnotationIntrospector(new JsonArrayFormat());
-        objectMapper.setSerializerFactory(new MessagePackSerializerFactory());
+        SimpleModule mod = new SimpleModule("test");
+        mod.addKeySerializer(TinyPojo.class, new MessagePackKeySerializer());
+        objectMapper.registerModule(mod);
         byte[] bytes = objectMapper.writeValueAsBytes(map);
 
         MessageUnpacker unpacker = MessagePack.newDefaultUnpacker(bytes);
diff --git a/msgpack-jackson/src/test/java/org/msgpack/jackson/dataformat/MessagePackMapperTest.java b/msgpack-jackson/src/test/java/org/msgpack/jackson/dataformat/MessagePackMapperTest.java
new file mode 100644
index 000000000..d14f97f2e
--- /dev/null
+++ b/msgpack-jackson/src/test/java/org/msgpack/jackson/dataformat/MessagePackMapperTest.java
@@ -0,0 +1,111 @@
+//
+// MessagePack for Java
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+package org.msgpack.jackson.dataformat;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import org.junit.jupiter.api.Test;
+
+import java.io.IOException;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.fail;
+
+public class MessagePackMapperTest
+{
+    static class PojoWithBigInteger
+    {
+        public BigInteger value;
+    }
+
+    static class PojoWithBigDecimal
+    {
+        public BigDecimal value;
+    }
+
+    private void shouldFailToHandleBigInteger(MessagePackMapper messagePackMapper) throws JsonProcessingException
+    {
+        PojoWithBigInteger obj = new PojoWithBigInteger();
+        obj.value = BigInteger.valueOf(Long.MAX_VALUE).multiply(BigInteger.valueOf(10));
+
+        try {
+            messagePackMapper.writeValueAsBytes(obj);
+            fail();
+        }
+        catch (IllegalArgumentException e) {
+            // Expected
+        }
+    }
+
+    private void shouldSuccessToHandleBigInteger(MessagePackMapper messagePackMapper) throws IOException
+    {
+        PojoWithBigInteger obj = new PojoWithBigInteger();
+        obj.value = BigInteger.valueOf(Long.MAX_VALUE).multiply(BigInteger.valueOf(10));
+
+        byte[] converted = messagePackMapper.writeValueAsBytes(obj);
+
+        PojoWithBigInteger deserialized = messagePackMapper.readValue(converted, PojoWithBigInteger.class);
+        assertEquals(obj.value, deserialized.value);
+    }
+
+    private void shouldFailToHandleBigDecimal(MessagePackMapper messagePackMapper) throws JsonProcessingException
+    {
+        PojoWithBigDecimal obj = new PojoWithBigDecimal();
+        obj.value = new BigDecimal("1234567890.98765432100");
+
+        try {
+            messagePackMapper.writeValueAsBytes(obj);
+            fail();
+        }
+        catch (IllegalArgumentException e) {
+            // Expected
+        }
+    }
+
+    private void shouldSuccessToHandleBigDecimal(MessagePackMapper messagePackMapper) throws IOException
+    {
+        PojoWithBigDecimal obj = new PojoWithBigDecimal();
+        obj.value = new BigDecimal("1234567890.98765432100");
+
+        byte[] converted = messagePackMapper.writeValueAsBytes(obj);
+
+        PojoWithBigDecimal deserialized = messagePackMapper.readValue(converted, PojoWithBigDecimal.class);
+        assertEquals(obj.value, deserialized.value);
+    }
+
+    @Test
+    public void handleBigIntegerAsString() throws IOException
+    {
+        shouldFailToHandleBigInteger(new MessagePackMapper());
+        shouldSuccessToHandleBigInteger(new MessagePackMapper().handleBigIntegerAsString());
+    }
+
+    @Test
+    public void handleBigDecimalAsString() throws IOException
+    {
+        shouldFailToHandleBigDecimal(new MessagePackMapper());
+        shouldSuccessToHandleBigDecimal(new MessagePackMapper().handleBigDecimalAsString());
+    }
+
+    @Test
+    public void handleBigIntegerAndBigDecimalAsString() throws IOException
+    {
+        MessagePackMapper messagePackMapper = new MessagePackMapper().handleBigIntegerAndBigDecimalAsString();
+        shouldSuccessToHandleBigInteger(messagePackMapper);
+        shouldSuccessToHandleBigDecimal(messagePackMapper);
+    }
+}
diff --git a/msgpack-jackson/src/test/java/org/msgpack/jackson/dataformat/MessagePackParserTest.java b/msgpack-jackson/src/test/java/org/msgpack/jackson/dataformat/MessagePackParserTest.java
index a416c92bd..256c43321 100644
--- a/msgpack-jackson/src/test/java/org/msgpack/jackson/dataformat/MessagePackParserTest.java
+++ b/msgpack-jackson/src/test/java/org/msgpack/jackson/dataformat/MessagePackParserTest.java
@@ -27,7 +27,7 @@
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.deser.std.StdDeserializer;
 import com.fasterxml.jackson.databind.module.SimpleModule;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.msgpack.core.MessagePack;
 import org.msgpack.core.MessagePacker;
 import org.msgpack.value.ExtensionValue;
@@ -52,10 +52,11 @@
 
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.core.Is.is;
-import static org.junit.Assert.assertArrayEquals;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
 public class MessagePackParserTest
         extends MessagePackDataformatTestBase
@@ -316,43 +317,43 @@ public void testMessagePackParserDirectly()
 
         JsonToken jsonToken = parser.nextToken();
         assertEquals(JsonToken.START_OBJECT, jsonToken);
-        assertEquals(-1, parser.getTokenLocation().getLineNr());
-        assertEquals(0, parser.getTokenLocation().getColumnNr());
-        assertEquals(-1, parser.getCurrentLocation().getLineNr());
-        assertEquals(1, parser.getCurrentLocation().getColumnNr());
+        assertEquals(-1, parser.currentTokenLocation().getLineNr());
+        assertEquals(0, parser.currentTokenLocation().getColumnNr());
+        assertEquals(-1, parser.currentLocation().getLineNr());
+        assertEquals(1, parser.currentLocation().getColumnNr());
 
         jsonToken = parser.nextToken();
         assertEquals(JsonToken.FIELD_NAME, jsonToken);
-        assertEquals("zero", parser.getCurrentName());
-        assertEquals(1, parser.getTokenLocation().getColumnNr());
-        assertEquals(6, parser.getCurrentLocation().getColumnNr());
+        assertEquals("zero", parser.currentName());
+        assertEquals(1, parser.currentTokenLocation().getColumnNr());
+        assertEquals(6, parser.currentLocation().getColumnNr());
 
         jsonToken = parser.nextToken();
         assertEquals(JsonToken.VALUE_NUMBER_INT, jsonToken);
         assertEquals(0, parser.getIntValue());
-        assertEquals(6, parser.getTokenLocation().getColumnNr());
-        assertEquals(7, parser.getCurrentLocation().getColumnNr());
+        assertEquals(6, parser.currentTokenLocation().getColumnNr());
+        assertEquals(7, parser.currentLocation().getColumnNr());
 
         jsonToken = parser.nextToken();
         assertEquals(JsonToken.FIELD_NAME, jsonToken);
-        assertEquals("one", parser.getCurrentName());
-        assertEquals(7, parser.getTokenLocation().getColumnNr());
-        assertEquals(11, parser.getCurrentLocation().getColumnNr());
+        assertEquals("one", parser.currentName());
+        assertEquals(7, parser.currentTokenLocation().getColumnNr());
+        assertEquals(11, parser.currentLocation().getColumnNr());
         parser.overrideCurrentName("two");
-        assertEquals("two", parser.getCurrentName());
+        assertEquals("two", parser.currentName());
 
         jsonToken = parser.nextToken();
         assertEquals(JsonToken.VALUE_NUMBER_FLOAT, jsonToken);
         assertEquals(1.0f, parser.getIntValue(), 0.001f);
-        assertEquals(11, parser.getTokenLocation().getColumnNr());
-        assertEquals(16, parser.getCurrentLocation().getColumnNr());
+        assertEquals(11, parser.currentTokenLocation().getColumnNr());
+        assertEquals(16, parser.currentLocation().getColumnNr());
 
         jsonToken = parser.nextToken();
         assertEquals(JsonToken.END_OBJECT, jsonToken);
-        assertEquals(-1, parser.getTokenLocation().getLineNr());
-        assertEquals(16, parser.getTokenLocation().getColumnNr());
-        assertEquals(-1, parser.getCurrentLocation().getLineNr());
-        assertEquals(16, parser.getCurrentLocation().getColumnNr());
+        assertEquals(-1, parser.currentTokenLocation().getLineNr());
+        assertEquals(16, parser.currentTokenLocation().getColumnNr());
+        assertEquals(-1, parser.currentLocation().getLineNr());
+        assertEquals(16, parser.currentLocation().getColumnNr());
 
         parser.close();
         parser.close(); // Intentional
@@ -450,7 +451,7 @@ public void setup(File f)
         return tempFile;
     }
 
-    @Test(expected = IOException.class)
+    @Test
     public void testEnableFeatureAutoCloseSource()
             throws Exception
     {
@@ -459,7 +460,9 @@ public void testEnableFeatureAutoCloseSource()
         FileInputStream in = new FileInputStream(tempFile);
         ObjectMapper objectMapper = new ObjectMapper(factory);
         objectMapper.readValue(in, new TypeReference<List<Integer>>() {});
-        objectMapper.readValue(in, new TypeReference<List<Integer>>() {});
+        assertThrows(IOException.class, () -> {
+            objectMapper.readValue(in, new TypeReference<List<Integer>>() {});
+        });
     }
 
     @Test
diff --git a/msgpack-jackson/src/test/java/org/msgpack/jackson/dataformat/TimestampExtensionModuleTest.java b/msgpack-jackson/src/test/java/org/msgpack/jackson/dataformat/TimestampExtensionModuleTest.java
new file mode 100755
index 000000000..074d7bf54
--- /dev/null
+++ b/msgpack-jackson/src/test/java/org/msgpack/jackson/dataformat/TimestampExtensionModuleTest.java
@@ -0,0 +1,218 @@
+//
+// MessagePack for Java
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+package org.msgpack.jackson.dataformat;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.msgpack.core.MessagePack;
+import org.msgpack.core.MessagePacker;
+import org.msgpack.core.MessageUnpacker;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.time.Instant;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class TimestampExtensionModuleTest
+{
+    private final ObjectMapper objectMapper = new ObjectMapper(new MessagePackFactory());
+    private final SingleInstant singleInstant = new SingleInstant();
+    private final TripleInstants tripleInstants = new TripleInstants();
+
+    private static class SingleInstant
+    {
+        public Instant instant;
+    }
+
+    private static class TripleInstants
+    {
+        public Instant a;
+        public Instant b;
+        public Instant c;
+    }
+
+    @BeforeEach
+    public void setUp()
+            throws Exception
+    {
+        objectMapper.registerModule(TimestampExtensionModule.INSTANCE);
+    }
+
+    @Test
+    public void testSingleInstantPojo()
+            throws IOException
+    {
+        singleInstant.instant = Instant.now();
+        byte[] bytes = objectMapper.writeValueAsBytes(singleInstant);
+        SingleInstant deserialized = objectMapper.readValue(bytes, SingleInstant.class);
+        assertEquals(singleInstant.instant, deserialized.instant);
+    }
+
+    @Test
+    public void testTripleInstantsPojo()
+            throws IOException
+    {
+        Instant now = Instant.now();
+        tripleInstants.a = now.minusSeconds(1);
+        tripleInstants.b = now;
+        tripleInstants.c = now.plusSeconds(1);
+        byte[] bytes = objectMapper.writeValueAsBytes(tripleInstants);
+        TripleInstants deserialized = objectMapper.readValue(bytes, TripleInstants.class);
+        assertEquals(now.minusSeconds(1), deserialized.a);
+        assertEquals(now, deserialized.b);
+        assertEquals(now.plusSeconds(1), deserialized.c);
+    }
+
+    @Test
+    public void serialize32BitFormat()
+            throws IOException
+    {
+        singleInstant.instant = Instant.ofEpochSecond(Instant.now().getEpochSecond());
+
+        byte[] bytes = objectMapper.writeValueAsBytes(singleInstant);
+
+        // Check the size of serialized data first
+        try (MessageUnpacker unpacker = MessagePack.newDefaultUnpacker(bytes)) {
+            unpacker.unpackMapHeader();
+            assertEquals("instant", unpacker.unpackString());
+            assertEquals(4, unpacker.unpackExtensionTypeHeader().getLength());
+        }
+
+        try (MessageUnpacker unpacker = MessagePack.newDefaultUnpacker(bytes)) {
+            unpacker.unpackMapHeader();
+            unpacker.unpackString();
+            assertEquals(singleInstant.instant, unpacker.unpackTimestamp());
+        }
+    }
+
+    @Test
+    public void serialize64BitFormat()
+            throws IOException
+    {
+        singleInstant.instant = Instant.ofEpochSecond(Instant.now().getEpochSecond(), 1234);
+
+        byte[] bytes = objectMapper.writeValueAsBytes(singleInstant);
+
+        // Check the size of serialized data first
+        try (MessageUnpacker unpacker = MessagePack.newDefaultUnpacker(bytes)) {
+            unpacker.unpackMapHeader();
+            assertEquals("instant", unpacker.unpackString());
+            assertEquals(8, unpacker.unpackExtensionTypeHeader().getLength());
+        }
+
+        try (MessageUnpacker unpacker = MessagePack.newDefaultUnpacker(bytes)) {
+            unpacker.unpackMapHeader();
+            unpacker.unpackString();
+            assertEquals(singleInstant.instant, unpacker.unpackTimestamp());
+        }
+    }
+
+    @Test
+    public void serialize96BitFormat()
+            throws IOException
+    {
+        singleInstant.instant = Instant.ofEpochSecond(19880866800L /* 2600-01-01 */, 1234);
+
+        byte[] bytes = objectMapper.writeValueAsBytes(singleInstant);
+
+        // Check the size of serialized data first
+        try (MessageUnpacker unpacker = MessagePack.newDefaultUnpacker(bytes)) {
+            unpacker.unpackMapHeader();
+            assertEquals("instant", unpacker.unpackString());
+            assertEquals(12, unpacker.unpackExtensionTypeHeader().getLength());
+        }
+
+        try (MessageUnpacker unpacker = MessagePack.newDefaultUnpacker(bytes)) {
+            unpacker.unpackMapHeader();
+            unpacker.unpackString();
+            assertEquals(singleInstant.instant, unpacker.unpackTimestamp());
+        }
+    }
+
+    @Test
+    public void deserialize32BitFormat()
+            throws IOException
+    {
+        Instant instant = Instant.ofEpochSecond(Instant.now().getEpochSecond());
+
+        ByteArrayOutputStream os = new ByteArrayOutputStream();
+        try (MessagePacker packer = MessagePack.newDefaultPacker(os)) {
+            packer.packMapHeader(1)
+                    .packString("instant")
+                    .packTimestamp(instant);
+        }
+
+        byte[] bytes = os.toByteArray();
+        try (MessageUnpacker unpacker = MessagePack.newDefaultUnpacker(bytes)) {
+            unpacker.unpackMapHeader();
+            unpacker.unpackString();
+            assertEquals(4, unpacker.unpackExtensionTypeHeader().getLength());
+        }
+
+        SingleInstant deserialized = objectMapper.readValue(bytes, SingleInstant.class);
+        assertEquals(instant, deserialized.instant);
+    }
+
+    @Test
+    public void deserialize64BitFormat()
+            throws IOException
+    {
+        Instant instant = Instant.ofEpochSecond(Instant.now().getEpochSecond(), 1234);
+
+        ByteArrayOutputStream os = new ByteArrayOutputStream();
+        try (MessagePacker packer = MessagePack.newDefaultPacker(os)) {
+            packer.packMapHeader(1)
+                    .packString("instant")
+                    .packTimestamp(instant);
+        }
+
+        byte[] bytes = os.toByteArray();
+        try (MessageUnpacker unpacker = MessagePack.newDefaultUnpacker(bytes)) {
+            unpacker.unpackMapHeader();
+            unpacker.unpackString();
+            assertEquals(8, unpacker.unpackExtensionTypeHeader().getLength());
+        }
+
+        SingleInstant deserialized = objectMapper.readValue(bytes, SingleInstant.class);
+        assertEquals(instant, deserialized.instant);
+    }
+
+    @Test
+    public void deserialize96BitFormat()
+            throws IOException
+    {
+        Instant instant = Instant.ofEpochSecond(19880866800L /* 2600-01-01 */, 1234);
+
+        ByteArrayOutputStream os = new ByteArrayOutputStream();
+        try (MessagePacker packer = MessagePack.newDefaultPacker(os)) {
+            packer.packMapHeader(1)
+                    .packString("instant")
+                    .packTimestamp(instant);
+        }
+
+        byte[] bytes = os.toByteArray();
+        try (MessageUnpacker unpacker = MessagePack.newDefaultUnpacker(bytes)) {
+            unpacker.unpackMapHeader();
+            unpacker.unpackString();
+            assertEquals(12, unpacker.unpackExtensionTypeHeader().getLength());
+        }
+
+        SingleInstant deserialized = objectMapper.readValue(bytes, SingleInstant.class);
+        assertEquals(instant, deserialized.instant);
+    }
+}
diff --git a/msgpack-jackson/src/test/java/org/msgpack/jackson/dataformat/benchmark/MessagePackDataformatHugeDataBenchmarkTest.java b/msgpack-jackson/src/test/java/org/msgpack/jackson/dataformat/benchmark/MessagePackDataformatHugeDataBenchmarkTest.java
index b3a159111..8ae73d0b5 100644
--- a/msgpack-jackson/src/test/java/org/msgpack/jackson/dataformat/benchmark/MessagePackDataformatHugeDataBenchmarkTest.java
+++ b/msgpack-jackson/src/test/java/org/msgpack/jackson/dataformat/benchmark/MessagePackDataformatHugeDataBenchmarkTest.java
@@ -19,7 +19,7 @@
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.core.type.TypeReference;
 import com.fasterxml.jackson.databind.ObjectMapper;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.msgpack.jackson.dataformat.MessagePackFactory;
 
 import java.io.File;
@@ -30,7 +30,7 @@
 
 public class MessagePackDataformatHugeDataBenchmarkTest
 {
-    private static final int ELM_NUM = 100000;
+    private static final int ELM_NUM = 1000000;
     private static final int COUNT = 6;
     private static final int WARMUP_COUNT = 4;
     private final ObjectMapper origObjectMapper = new ObjectMapper();
diff --git a/msgpack-jackson/src/test/java/org/msgpack/jackson/dataformat/benchmark/MessagePackDataformatPojoBenchmarkTest.java b/msgpack-jackson/src/test/java/org/msgpack/jackson/dataformat/benchmark/MessagePackDataformatPojoBenchmarkTest.java
index 179b09891..8042153d3 100644
--- a/msgpack-jackson/src/test/java/org/msgpack/jackson/dataformat/benchmark/MessagePackDataformatPojoBenchmarkTest.java
+++ b/msgpack-jackson/src/test/java/org/msgpack/jackson/dataformat/benchmark/MessagePackDataformatPojoBenchmarkTest.java
@@ -15,17 +15,13 @@
 //
 package org.msgpack.jackson.dataformat.benchmark;
 
-import com.fasterxml.jackson.core.JsonGenerator;
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.ObjectMapper;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.msgpack.jackson.dataformat.MessagePackFactory;
 import static org.msgpack.jackson.dataformat.MessagePackDataformatTestBase.NormalPojo;
 import static org.msgpack.jackson.dataformat.MessagePackDataformatTestBase.Suit;
 
-import java.io.File;
-import java.io.FileOutputStream;
-import java.io.OutputStream;
 import java.math.BigInteger;
 import java.util.ArrayList;
 import java.util.List;
@@ -45,9 +41,6 @@ public class MessagePackDataformatPojoBenchmarkTest
 
     public MessagePackDataformatPojoBenchmarkTest()
     {
-        origObjectMapper.configure(JsonGenerator.Feature.AUTO_CLOSE_TARGET, false);
-        msgpackObjectMapper.configure(JsonGenerator.Feature.AUTO_CLOSE_TARGET, false);
-
         for (int i = 0; i < LOOP_MAX; i++) {
             NormalPojo pojo = new NormalPojo();
             pojo.i = i;
@@ -76,6 +69,7 @@ public MessagePackDataformatPojoBenchmarkTest()
                     break;
             }
             pojo.b = new byte[] {(byte) i};
+            pojo.sMultibyte = "012345678Ⅸ";
             pojos.add(pojo);
         }
 
@@ -104,14 +98,6 @@ public void testBenchmark()
     {
         Benchmarker benchmarker = new Benchmarker();
 
-        File tempFileJackson = File.createTempFile("msgpack-jackson-", "-huge-jackson");
-        tempFileJackson.deleteOnExit();
-        final OutputStream outputStreamJackson = new FileOutputStream(tempFileJackson);
-
-        File tempFileMsgpack = File.createTempFile("msgpack-jackson-", "-huge-msgpack");
-        tempFileMsgpack.deleteOnExit();
-        final OutputStream outputStreamMsgpack = new FileOutputStream(tempFileMsgpack);
-
         benchmarker.addBenchmark(new Benchmarker.Benchmarkable("serialize(pojo) with JSON") {
             @Override
             public void run()
@@ -119,7 +105,7 @@ public void run()
             {
                 for (int j = 0; j < LOOP_FACTOR_SER; j++) {
                     for (int i = 0; i < LOOP_MAX; i++) {
-                        origObjectMapper.writeValue(outputStreamJackson, pojos.get(i));
+                        origObjectMapper.writeValueAsBytes(pojos.get(i));
                     }
                 }
             }
@@ -132,7 +118,7 @@ public void run()
             {
                 for (int j = 0; j < LOOP_FACTOR_SER; j++) {
                     for (int i = 0; i < LOOP_MAX; i++) {
-                        msgpackObjectMapper.writeValue(outputStreamMsgpack, pojos.get(i));
+                        msgpackObjectMapper.writeValueAsBytes(pojos.get(i));
                     }
                 }
             }
@@ -164,12 +150,6 @@ public void run()
             }
         });
 
-        try {
-            benchmarker.run(COUNT, WARMUP_COUNT);
-        }
-        finally {
-            outputStreamJackson.close();
-            outputStreamMsgpack.close();
-        }
+        benchmarker.run(COUNT, WARMUP_COUNT);
     }
 }
diff --git a/project/build.properties b/project/build.properties
index 71aac7fe5..b1b10405c 100755
--- a/project/build.properties
+++ b/project/build.properties
@@ -1,2 +1,2 @@
-sbt.version=1.5.6
+sbt.version=1.11.7
 
diff --git a/project/plugins.sbt b/project/plugins.sbt
old mode 100755
new mode 100644
index 1609ca903..a7594c7a3
--- a/project/plugins.sbt
+++ b/project/plugins.sbt
@@ -1,11 +1,10 @@
-addSbtPlugin("org.xerial.sbt" % "sbt-sonatype" % "3.9.10")
-addSbtPlugin("com.github.sbt" % "sbt-pgp"      % "2.1.2")
+addSbtPlugin("com.github.sbt" % "sbt-pgp" % "2.3.1")
 // TODO: Fixes jacoco error:
 // java.lang.NoClassDefFoundError: Could not initialize class org.jacoco.core.internal.flow.ClassProbesAdapter
 //addSbtPlugin("com.github.sbt"   % "sbt-jacoco"      % "3.3.0")
-addSbtPlugin("org.xerial.sbt"   % "sbt-jcheckstyle" % "0.2.1")
-addSbtPlugin("com.typesafe.sbt" % "sbt-osgi"        % "0.9.6")
-addSbtPlugin("org.scalameta"    % "sbt-scalafmt"    % "2.4.5")
-addSbtPlugin("com.dwijnand"     % "sbt-dynver"      % "4.1.1")
+addSbtPlugin("org.xerial.sbt" % "sbt-jcheckstyle" % "0.2.1")
+addSbtPlugin("com.github.sbt" % "sbt-osgi"        % "0.10.0")
+addSbtPlugin("org.scalameta"  % "sbt-scalafmt"    % "2.5.6")
+addSbtPlugin("com.github.sbt" % "sbt-dynver"      % "5.1.1")
 
 scalacOptions ++= Seq("-deprecation", "-feature")
diff --git a/sbt b/sbt
index 18c6b1125..0c5112ba7 100755
--- a/sbt
+++ b/sbt
@@ -34,11 +34,11 @@
 
 set -o pipefail
 
-declare -r sbt_release_version="1.5.5"
-declare -r sbt_unreleased_version="1.6.0-M1"
+declare -r sbt_release_version="1.8.2"
+declare -r sbt_unreleased_version="1.8.2"
 
-declare -r latest_213="2.13.7"
-declare -r latest_212="2.12.15"
+declare -r latest_213="2.13.10"
+declare -r latest_212="2.12.17"
 declare -r latest_211="2.11.12"
 declare -r latest_210="2.10.7"
 declare -r latest_29="2.9.3"
diff --git a/sonatype.sbt b/sonatype.sbt
deleted file mode 100644
index f016335a0..000000000
--- a/sonatype.sbt
+++ /dev/null
@@ -1,18 +0,0 @@
-import xerial.sbt.Sonatype._
-
-ThisBuild / sonatypeProfileName := "org.msgpack"
-ThisBuild / homepage := Some(url("https://msgpack.org/"))
-ThisBuild / licenses := Seq("APL2" -> url("http://www.apache.org/licenses/LICENSE-2.0.txt"))
-ThisBuild / scmInfo := Some(
-  ScmInfo(
-    url("https://github.com/msgpack/msgpack-java"),
-    "scm:git@github.com:msgpack/msgpack-java.git"
-  )
-)
-ThisBuild / developers := List(
-  Developer(id = "frsyuki", name = "Sadayuki Furuhashi", email = "frsyuki@users.sourceforge.jp", url = url("https://github.com/frsyuki")),
-  Developer(id = "muga", name = "Muga Nishizawa", email = "muga.nishizawa@gmail.com", url = url("https://github.com/muga")),
-  Developer(id = "oza", name = "Tsuyoshi Ozawa", email = "ozawa.tsuyoshi@gmail.com", url = url("https://github.com/oza")),
-  Developer(id = "komamitsu", name = "Mitsunori Komatsu", email = "komamitsu@gmail.com", url = url("https://github.com/komamitsu")),
-  Developer(id = "xerial", name = "Taro L. Saito", email = "leo@xerial.org", url = url("https://github.com/xerial"))
-)